Recent PostsMonitoring Spring boot application using Prometheus and GrafanaJuly 5, 2020UncategorizedIn continuation with previous article ,we will see how we can monitor spring boot application developed in earlier post with actuator. We have already seen prometheus tool for monitoring application but as prometheus doesn’t provide better visualization experience, we have to go with other tools which has rich UI for better visualization of application metrics. You can use Grafana for the better visualization . Grafana While Prometheus does provide some crude visualization, Grafana offers a rich UI where you can build up custom graphs quickly and create a dashboard out of many graphs in no time. You can also import many community built dashboards for free and get going. Grafana can pull data from various data sources like Prometheus, Elasticsearch, InfluxDB, etc. It also allows you to set rule-based alerts, which then can notify you over Slack, Email, Hipchat, and similar. Let’s start with running Grafana using Doc You can download grafana for windows using below link – https://grafana.com/grafana/dashboards If you visit http://localhost:3000, you will be redirected to a login page: Login page Default credentials to login are admin/admin . Since Grafana works with many data sources, we need to define which one we’re relying on. In our case we have to select Prometheus as our data source: Datasource configuration Select Prometheus from below provided options – Now, add the URL that Prometheus is running on, in our case http://localhost:9090 and select Access to be through a browser. At this point, we can save and test to see if the data source is working correctly: You can search for JVM (Micrometer) dashboard on grafana website and provide its ID in next step to import that dashboard into grafana – You can find the dashboard ID as highlighted in below screenshot – As i mentioned earlier, Grafana has lots of of pre-built dashboards. For Spring Boot projects, the JVM dashboard is popular. We are going to use JVM micrometer (ID = 4701) dashboard in this example . Click on highlighted plus icon and then import – Select the Prometheus datasource name created in earlier steps as highlighted in below screenshot- Once you click on import , your dashboard is ready . You can have a look at all the metrics exposed by prometheus on a single dashboard – I hope this tutorial is helpful for you to configure your spring boot application with Grafana In this article, we used Micrometer to reformat the metrics data provided by Spring Boot Actuator and expose it in a new endpoint. This data was then regularly pulled and stored by Prometheus, which is a time-series database. Ultimately, we’ve used Grafana to visualize this information with a user-friendly dashboard. Monitoring an application’s health and metrics helps us manage it better, notice unoptimized behavior, and better understand its performance. This especially holds true when we’re developing a system with many microservices, where monitoring each service can prove to be crucial when it comes to maintaining our system. Based on this information, we can draw conclusions and decide which microservice needs to scale if further performance improvements can’t be achieved with the current setup. Github Downlod Link: Download... Read more...Spring mvc integration with prometheus ExampleApril 27, 2020Spring CoreIn this article ,we will see how we can monitor spring MVC applications using prometheus tool . You wont get much documentation for this setup on web. Prometheus is mostly configured with spring boot easily. But in order to configure it with spring MVC based application , it requires some additional configurations – Prometheus Prometheus is a time-series monitoring application written in Go. It can run on a server, in a docker container, or as part of a Kubernetes cluster (or something similar). Prometheus collects, stores, and visualizes time-series data so that you can monitor your systems. You can tell Prometheus exactly where to find metrics by configuring a list of “scrape jobs”. Applications that are being monitored can provide metrics endpoints to Prometheus using any one of the many client libraries available; additionally, separate exporters can gather metrics from applications to make them available in Prometheus. Metrics get stored locally for 15 days, by default, and any Prometheus server can scrape another one for data. Additionally, remote storage is another option for Prometheus data – provided there is a reliable remote storage endpoint. Benefits: The option of “service discovery” allows Prometheus to keep track of all current endpoints effortlessly. Outages are quickly detected .The PromQL query language is incredibly flexible and Turing-complete. There’s also a very low load on the services monitored (metrics get stored in memory as they get generated), allowing fewer resources to get used. Additionally, Prometheus users can control traffic volumes, access metrics in the browser, and allow for easy reconfiguration. Step 1 : Spring MVC application pom.xml configuration Below prometheus dependencies are required in pom.xml for project – 0.6.0 io.prometheus simpleclient ${prometheus.version} io.prometheus simpleclient_hotspot ${prometheus.version} io.prometheus simpleclient_servlet ${prometheus.version} io.prometheus simpleclient_pushgateway ${prometheus.version} io.prometheus simpleclient_spring_web ${prometheus.version} com.fasterxml.jackson.core jackson-core 2.5.2 Step 2 : Spring MVC application web.xml configuration We need configure MetricsServlet to capture the metrics of our spring mvc application as below – PrometheusServlet io.prometheus.client.exporter.MetricsServlet PrometheusServlet /metrics Step 3: Add an interceptor class This will intercept all the requests coming to application and capture the metrics to be exposed to prometheus – package com.myjavablog.config; import io.prometheus.client.Counter; import io.prometheus.client.Gauge; import io.prometheus.client.Histogram; import io.prometheus.client.Summary; import org.apache.log4j.Logger; import org.springframework.web.method.HandlerMethod; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.handler.HandlerInterceptorAdapter; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * @author anupb */ public class PrometheusMetricsInterceptor extends HandlerInterceptorAdapter { private static Logger logger = Logger.getLogger(PrometheusMetricsInterceptor.class); private static final Histogram requestLatency = Histogram.build() .name(“service_requests_latency_seconds”) .help(“Request latency in seconds.”) .labelNames(“systemId”, “appId”, “type”, “name”, “method”).register(); private ThreadLocal timerThreadLocal; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { return super.preHandle(request, response, handler); } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { String name = this.getName(request, handler).toLowerCase(); String method = request.getMethod().toUpperCase(); timerThreadLocal = new ThreadLocal(); timerThreadLocal.set(requestLatency.labels(name, method).startTimer()); super.postHandle(request, response, handler, modelAndView); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { super.afterCompletion(request, response, handler, ex); if (timerThreadLocal.get() != null) { timerThreadLocal.get().observeDuration(); } } @Override public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { super.afterConcurrentHandlingStarted(request, response, handler); } private String getName(HttpServletRequest request, Object handler) { String name = “”; try { if (handler != null && handler instanceof HandlerMethod) { HandlerMethod method = (HandlerMethod) handler; String className = ((HandlerMethod) handler).getBeanType().getName(); name = className + “.” + method.getMethod().getName(); } else { name = request.getRequestURI(); } } catch (Exception ex) { logger.error(“getName”, ex); } finally { return name; } } } Step 4: Add prometheus initialization configuration This will expose the metrics to prometheus server – package com.myjavablog.config; public class PrometheusConfig { private static Logger logger = Logger.getLogger(PrometheusConfig.class); @PostConstruct public void initialize() { logger.info(“prometheus init…”); DefaultExports.initialize(); logger.info(“prometheus has been initialized…”); } } Step 5: Add an interceptor to spring-mvc.xml You need to first add the schema location as below – http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd Then you need to add below tag – <mvc:interceptors> <bean class="com.xx.config.PrometheusMetricsInterceptor"/> </mvc:interceptors> Step 6: Add configuration to applicationcontext.xml Once all this configuration is done , you can add the application URL in prometheus. These parameters are useful to monitor your spring MVC application.... Read more...Monitoring Spring boot applications using actuator and prometheusMarch 15, 2020Spring BootIn this article ,we will see how we can monitor spring boot applications using actuator spring boot project and prometheus tool . Prometheus Prometheus is a time-series monitoring application written in Go. It can run on a server, in a docker container, or as part of a Kubernetes cluster (or something similar). Prometheus collects, stores, and visualizes time-series data so that you can monitor your systems. You can tell Prometheus exactly where to find metrics by configuring a list of “scrape jobs”. Applications that are being monitored can provide metrics endpoints to Prometheus using any one of the many client libraries available; additionally, separate exporters can gather metrics from applications to make them available in Prometheus. Metrics get stored locally for 15 days, by default, and any Prometheus server can scrape another one for data. Additionally, remote storage is another option for Prometheus data – provided there is a reliable remote storage endpoint. Benefits: The option of “service discovery” allows Prometheus to keep track of all current endpoints effortlessly. Outages are quickly detected .The PromQL query language is incredibly flexible and Turing-complete. There’s also a very low load on the services monitored (metrics get stored in memory as they get generated), allowing fewer resources to get used. Additionally, Prometheus users can control traffic volumes, access metrics in the browser, and allow for easy reconfiguration. Part 1: Spring boot application configuration We will create a simple spring boot REST application which will expose the metrics to prometheus. Please find below project structure of application – Project Structure Below is the pom.xml required for project – 4.0.0 com.db spring-boot-prometheus 1.0-SNAPSHOT org.springframework.boot spring-boot-starter-parent 2.1.9.RELEASE 1.8 org.springframework.boot spring-boot-starter-actuator org.springframework.boot spring-boot-starter-web io.micrometer micrometer-registry-prometheus org.springframework.boot spring-boot-starter-test test org.springframework.boot spring-boot-maven-plugin We need spring-boot-starter-actuator dependency ,this would expose the endpoints of our application and makes it available to prometheus server. You can run the application and check the endpoints exposed by actuator by hitting below link in browser – http://localhost:8081/actuator Micrometer micrometer-registry-prometheus dependency is required to register metrics with prometheus server. It exposes Actuator metrics to external monitoring systems such as Prometheus, Netflix Atlas, AWS Cloudwatch, and many more. Similarly, Micrometer automatically exposes /actuator/metrics data into something your monitoring system can understand. All you need to do is include that vendor-specific micrometer dependency in your application. Micrometer is a separate open-sourced project and is not in the Spring ecosystem, so we have to explicitly add it as a dependency. Since we will be using Prometheus, let’s add it’s specific dependency in our pom.xml: Part 2: Prometheus Server Configuration For this example , i will be installing portable prometheus on local system . You can download the prometheus setup from official prometheus website as below – https://prometheus.io/download/ You need to make below changes in prometheus.yml file of prometheus configuration to scrape the metrices your application .Please add below job to scrape the metrices of your application – # Details to connect Prometheus with Spring Boot actuator end point to scrap the data # The job name is added as a label `job=` to any time series scraped from this config. – job_name: ‘spring-actuator’ # Actuator end point to collect the data. metrics_path: ‘/actuator/prometheus’ #How frequently to scape the data from the end point scrape_interval: 5s #target end point. We are using the Docker, so local host will not work. You can change it with #localhost if not using the Docker. static_configs: – targets: Run the prometheus server by double clicking prometheus.exe flie . Now prometheus console will open and it will strat gathering the metrices of your application. You can access the prometheus server in browser using http://localhost:9090 Targets for metrics Classes loaded in JVM prometheus metrics Number of Threads in different states You can gather the metrices of your application by selecting the various parameters provided by prometheus like – jvm_classes_loaded_classesjvm_threads_live_threadsjvm_threads_states_threadsjvm_threads_states_threadstomcat_global_request_seconds_count These parameters are useful to monitor your systems. In the next article, we will create a prometheus server using docker and expose the metrices. Github Downlod Link: Download... Read more...Spring Cloud Eureka and Hystrix Circuit Breaker using MicroservicesJanuary 10, 2020MicroserviceIn this tutorial, we will use a microservice application created in previous post ( Microservices Example using Spring Cloud Eureka ) and add circuit breaker pattern using Hystrix Spring library in java. Using Hystrix in your application helps to add defensive mechanism and makes applications more resilient and fault tolerant. Tools Required – Java 8IntelliJ IDE We have created three different applications as below – Eureka Service– This Service will register every microservice and then the client microservice will look up the Eureka server to get a dependent microservice to get the job done.This Eureka Server is owned by Netflix and in this, Spring Cloud offers a declarative way to register and invoke services by using Java annotation.demo-server – This service will return a simple hello message.demo-client – It is similar to the standalone client service created in Bootiful Development with Spring Boot. It will consume the APIs provided by demo-server through Eureka Service . Hystrix Documentation – https://github.com/Netflix/Hystrix/wiki Microservices are deployed on Cloud . As cloud provides a distributed environment , there are more chances that some of your services may be down at some point of time. You can have several micro-services in your application which are dependent on each other. So one service can call to other service. If destination service is down then source will get an exception in normal scenario. But with the help of Hystrix annotations , you can add fallback mechanism and handle the exception in services. Thus it makes your service more fault tolerant, resilient . You need to add below dependency in your demo-client service application to enable Hystrix circuit breaker pattern – <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-hystrix</artifactId> <version>1.2.5.RELEASE</version> </dependency> We just have to add few annotations to handle fallback or break the service call in case your destination service(demo-server) is down. We need to change main class to enable Hystrix circuit breaker – package com.myjavablog.democlient; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; import org.springframework.cloud.client.loadbalancer.LoadBalanced; import org.springframework.cloud.netflix.hystrix.EnableHystrix; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @EnableCircuitBreaker @EnableDiscoveryClient @SpringBootApplication public class DemoClientApplication { public static void main(String[] args) { SpringApplication.run(DemoClientApplication.class, args); } } @Configuration class Config{ @Bean @LoadBalanced public RestTemplate restTemplate(){ return new RestTemplate(); } } Also we need to change controller class to add fallback mehod as below – package com.myjavablog.democlient; import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; @RestController @RequestMapping("/demo/hello/client") public class TestController { @Autowired public RestTemplate restTemplate; @GetMapping @HystrixCommand(fallbackMethod = "handleFallback") public String test(){ String url = "http://demo-server/demo/hello/server"; return restTemplate.getForObject(url, String.class); } public String handleFallback(){ return "Fallback hello service"; } } By default hystrix has timeout of 1 second for every request. So we need to disable timeout by setting below property in application.properties file – hystrix.command.default.execution.timeout.enabled=false So now i am intentionally stopping demo-server microservice and then we will make call to api to see fallback is working properly .You can see demo-server is not registered with Eureka below – So now when you call the service ,it should show you a fallback message as below – Github Downlod Link: Download... Read more...Benefits of microservicesJanuary 1, 2020MicroserviceYou start building microservices because they give you a high degree of flexibility and autonomy with your development teams, but you and your team quickly find that the small, independent nature of microservices makes them easily deployable to the cloud. Once the services are in the cloud, their small size makes it easy to start up large numbers of instances of the same service, and suddenly your applications become more scalable and with forethought, more resilient. A microservice architecture has the following characteristics: Application logic is broken down into small-grained components with well defined boundaries of responsibility that coordinate to deliver a solution.Each component has a small domain of responsibility and is deployed completely independently of one another. Microservices should have responsibility for a single part of a business domain. Also, a microservice should be reusable across multiple applications.Microservices communicate based on a few basic principles (notice I said principles, not standards) and employ lightweight communication protocols such as HTTP and JSON (JavaScript Object Notation) for exchanging data between the service consumer and service provider.The underlying technical implementation of the service is irrelevant because the applications always communicate with a technology-neutral protocol (JSON is the most common). This means an application built using a microservice application could be built with multiple languages and technologies.Microservices—by their small, independent, and distributed nature—allow organizations to have small development teams with well-defined areas of responsibility. These teams might work toward a single goal such as delivering an application, but each team is responsible only for the services on which they’re working.... Read more...What’s a microservice?December 29, 2019MicroserviceBefore the concept of microservices evolved, most web-based applications were built using a monolithic architectural style. In a monolithic rchitecture, an application is delivered as a single deployable software artifact. All the UI (user interface), business and database access logic are packaged together into a single application artifact and deployed to an application server.While an application might be a deployed as a single unit of work, most of the time there will be multiple development teams working on the application. Each development team will have their own discrete pieces of the application they’re responsible for and oftentimes specific customers they’re serving with their functional piece. For example, customer relations management (CRM) application that involves the coordination of multiple teams including the UI, the customer master, the data warehouse and the mutual funds teams. Below Figure illustrates the basic architecture of this application. Monolithic applications force multiple development teams to artificially synchronize their delivery because their code needs to be built, tested, and deployed as an entire unit. The problem here is that as the size and complexity of the monolithic CRM application grew, the communication and coordination costs of the individual teams working on the application didn’t scale. Every time an individual team needed to make a change, the entire application had to be rebuilt, retested and redeployed. A microservice is a small, loosely coupled, distributed service. Microservices allow you to take a large application and decompose it into easy-to manage components with narrowly defined responsibilities. Microservices help combat the traditional problems of complexity in a large code base by decomposing the large code base down into small, well-defined pieces. The key concept you need to embrace as you think about microservices is decomposing and unbundling the functionality of your applications so they’re completely independent of one another. If we take the CRM application we saw in above figure and decompose it into microservices, it might look like what’s shown in below figure.Looking at below figure, you can see that each functional team completely owns their service code and service infrastructure. They can build, deploy, and test independently of each other because their code, source control repository, and the infrastructure (app server and database) are now completely independent of the other parts of the application. A microservice architecture of CRM application would be decomposed into a set of microservices completely independent of each other, allowing each development team to move at their own pace.... Read more...Microservices Example using Spring Cloud EurekaDecember 29, 2019MicroserviceIn this tutorial, we will create a demo microservice using spring boot framework in java. Tools Required – Java 8IntelliJ IDE We need to create three different applications as below – Eureka Service– This Service will register every microservice and then the client microservice will look up the Eureka server to get a dependent microservice to get the job done.This Eureka Server is owned by Netflix and in this, Spring Cloud offers a declarative way to register and invoke services by using Java annotation.demo-server – This service will return a simple hello message.demo-client – It is similar to the standalone client service created in Bootiful Development with Spring Boot. It will consume the APIs provided by demo-server through Eureka Service . 1. Eureka Service We need to create new project in intelliJ editor by selecting below dependencies – Project Setup Maven dependencies You need to do below configurations to create Eureka service which allows other microservices to register with it . package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; @EnableEurekaServer @SpringBootApplication public class EurekaServiceApplication { public static void main(String[] args) { SpringApplication.run(EurekaServiceApplication.class, args); } } You need to create application.yml to configure your EurekaService project as register service. Other services will be able to register themselves with EurekaService. So you need to do below configurations – eureka: client: registerWithEureka: false fetchRegistry: false server: waitTimeInMsWhenSyncEmpty: 0 Now you can run the application . Once the application is up and running you can go to below URL and see EurekaService is working . You will be able to see below home page of eureka- As no instances are registered with EurekaService , you can see No instances available message as highlighted above . Now we will create services which will register with our Eureka Server. 2. Demo Server This is a simple REST based webservice. This will be registering itself with the EurekaService. This service has a simple API which is just returning hello message. Create a project structure as shown below in IntelliJ IDE – Setup Maven Dependencies required Project structure is as shown below – You need to include Eureka Discovery client dependency in your pom file. Once the application is up and running , you can see instance of demo-server registered on EurekaService as shown below – 3. Demo Client Same way as Demo server , we need to create demo client which will consume services provided by demo-server through EurekaService. demo-client will have autowired RestTemplate to call the services provided by demo-server. package com.myjavablog.democlient; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; @RestController @RequestMapping("/demo/hello/client") public class TestController { @Autowired public RestTemplate restTemplate; @GetMapping public String test(){ String url = "http://demo-server/demo/hello/server"; return restTemplate.getForObject(url, String.class); } } Also you can see in the above code , we are using String url = “http://demo-server/demo/hello/server” demo-server is the name specified in the application.yml file of demo-server project . So instead of using http://localhost:8071/demo/hello/server we are using http://demo-server/demo/hello/server . demo-server is the name registered on Eureka server for demo-server application as shown below – spring: application: name: demo-server server: port: 8071 eureka: client: registerWithEureka: true fetchRegistry: true serviceUrl: defaultZone: http://localhost:8070/eureka/ instance: hostname: localhost Once the application is up and running , you can see the demo-client is registered on Eureka Server as below – When you call the APIs from demo client ,it will internally call demo-server APIs through Eureka Service . Eureka server handles all routing and load balancing part. So even if you scale up your services in future by creating multiple instances, you can go on and use the services with the name which is registered on Eureka server. Github Downlod Link: Download... Read more...Spring Boot profilesDecember 1, 2019Spring BootIn this article, we will see profiles for spring boot project – Github Link – Download What are Profiles? Every enterprise application has many environments, like: Dev | Test | Stage | Prod | UAT / Pre-Prod Each environment requires a setting that is specific to them. For example, in DEV, we do not need to constantly check database consistency. Whereas in TEST and STAGE, we need to. These environments host specific configurations called Profiles. How do we Maintain Profiles? In spring boot application, we need different configurations for different environments. We have application.properties file to maintain application specific properties. In order to create profiles for different environments , we need to create various properties files as below – DEV – application-dev.properties TEST– application-test.properties PROD – application-prod.properties Step 1: Create below project structure in IntelliJ Step 2: We are creating 3 different property files for below mentioned environments – DEV – application-dev.properties TEST– application-test.properties PROD – application-prod.properties Of course, the application.properties will remain as a master properties file, but if we override any key in the profile-specific file, the latter will gain precedence. Step 3: Specify in application.properties file which environment property needs to be loaded spring.profiles.active=prod spring.application.name=springbootprofiles app.message = This is Application property for ${spring.application.name} Here we are loading PROD properties when application gets booted. Step 4: Define DB configuration properties for in respective properties file and add code in DBConfiguration.class to pick the appropriate settings. package com.myjavablog.config; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Profile; @Configuration @ConfigurationProperties("spring.datasource") public class DBConfiguration { private String driverClassName; private String url; private String username; private String password; public String getDriverClassName() { return driverClassName; } public void setDriverClassName(String driverClassName) { this.driverClassName = driverClassName; } public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } @Profile("dev") @Bean public String devDatabaseConnection() { System.out.println("DB connection for DEV - H2"); System.out.println(driverClassName); System.out.println(url); return "DB connection for DEV - H2"; } @Profile("test") @Bean public String testDatabaseConnection() { System.out.println("DB Connection to TEST -H2"); System.out.println(driverClassName); System.out.println(url); return "DB Connection to TEST -H2"; } @Profile("prod") @Bean public String prodDatabaseConnection() { System.out.println("DB Connection to PROD - H2"); System.out.println(driverClassName); System.out.println(url); return "DB Connection to PROD - H2"; } } This will load the properties file as per the spring.profiles.active property we have mentioned in application.properties file. Step 5: Output As per the application boot time logs below, you can see PROD database is loaded during application boot up. 2019-12-01 23:29:07.199 INFO 5728 --- rmationExtractorJdbcDatabaseMetaDataImpl : HHH000262: Table not found: user_details 2019-12-01 23:29:07.419 INFO 5728 --- j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default' DB Connection to PROD - H2 org.h2.Driver jdbc:h2:mem:proddb;DB_CLOSE_ON_EXIT=FALSE 2019-12-01 23:29:09.147 INFO 5728 --- s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot[email protected]e25951c: startup date ; root of context hierarchy You can connect to database as shown below –... Read more...How to create a Chat Bot in AzureOctober 24, 2019Azure / CloudClick Create new resource link found on the upper left-hand corner of the Azure portal, then select AI + Machine Learning > Web App bot. Once you select “Web App bot” , you have to configure it with below fields – Once you click on Create , your bot will be created .In the Bot Management section, click Test in Web Chat. Azure Bot Service will load the Web Chat control and connect to your bot. You can download the bot source code as shown below and configure the bot as per your requirements .... Read more...How to Deploy a Spring Boot application to AzureOctober 22, 2019Azure / CloudBelow are the tools required for this tutorial – MavenGit ClientAzure CLIJDKAzure Subscription Create a Spring boot application Open a git bash terminal window.Clone the below sample project into the directory you created by typing git clone https://github.com/AnupBhagwat7/azure-demo-service.gitChange to the directory of the completed project by typing cd azure-demo-service Build the JAR file using Maven by typing mvn clean packageWhen the web app has been created, start it by typing mvn spring-boot:runTest it locally by visiting http://localhost:8080/api/helloYou should see the following message displayed: Hello spring boot on azure! REST API Response in Browser Create an Azure service principal In this section, you will create an Azure service principal that the Maven plugin uses when deploying your web app to Azure. Open a terminal window.Sign into your Azure account with the Azure CLI by typing az loginCreate an Azure service principal by typing az ad sp create-for-rbac –name “uuuuuuuu” –password “pppppppp” (uuuuuuuu is the user name and pppppppp is the password for the service principal). Azure should print out a JSON response resembling this: { "appId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", "displayName": "servicename", "name": "http://servicename", "password": "pass", "tenant": "tttttttt-tttt-tttt-tttt-tttttttttttt" } Configure Maven to use your Azure service principal In this section, you will configure Maven to authenticate using your Azure service principal for web app deployment. Open your Maven settings.xml file in a text editor (usually found at either /etc/maven/settings.xml or $HOME/.m2/settings.xml). Add your Azure service principal settings from the previous section of this tutorial to the collection in the settings.xml file as shown below: <servers> <server> <id>azure-auth</id> <configuration> <client>aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa</client> <tenant>tttttttt-tttt-tttt-tttt-tttttttttttt</tenant> <key>pass</key> <environment>AZURE</environment> </configuration> </server> </servers> Save and close the settings.xml file. You need to configure Maven Plugin for Azure Web Apps deployment. Below entry needs to be added in pom.xml – <plugin> <groupId>com.microsoft.azure</groupId> <artifactId>azure-webapp-maven-plugin</artifactId> <version>1.1.0</version> <configuration> <!-- Azure configuration --> </configuration> </plugin> Build and deploy your app to Azure Once you have configured all of the settings in the previous sections, you are ready to deploy your web app to Azure. From the git bash terminal window, deploy your web app to Azure with Maven by typing mvn azure-webapp:deploy Maven will deploy your web app to Azure using a plugin already in the build file of the sample project you cloned earlier. If the web app doesn’t already exist, it will be created. When your web app has been deployed, visit the Azure portal to manage it. It will be listed in App Services as show below: Web app will be listed in Azure portal App Services. Click on the application. From there, the publicly-facing URL for your web app will be listed in the Overview section. Determining the URL for your web app You can click on this link to visit the Spring Boot application and interact with it.... Read more...How to create database instance in AzureOctober 19, 2019Azure / CloudStep 1: Azure Subscription You would need to subscribe for azure portal in order to use azure services. Below is the link for azure portal – https://portal.azure.com/ If you do not have an Azure account, provide your email or telephone number and it will verify that you are not in the system and will invite you to create an account. There is an option for a free trial account with $200 USD in credits for 30 days, so you can play with Azure resources without spending money during those 30 days. Step 2: Create SQL Database Once you are subscribed on azure , you can go to “SQL Databases” link and click “Create SQL Database”. Once you click on “Create SQL Database” , you will see the form as below – Step 3: Create Server In order to create database instance ,you need to create server as highlighted below – Step 4: Create Database Instance After all the configuration is done , you can create database instance by clicking Review + Create button as shown below – Now the database instance is up and running as shown below screen – Step 5: Access Database You can see database details once you open the resource as below – You connect to database using visual studio to perform various operations – You need to install below plugin in Visual Code Studio to connect to database. Once the plugin is installed , you can connect to database by giving database details . When you try to connect to database, you need to enable firewall on the database instance to make it secure and accessible to outside world. You can add firewall rule as shown below – Also you can connect and access database from azure platform –... Read more...How to host angular application using Azure CloudOctober 12, 2019Azure / CloudIn this post , i will introduce you to azure cloud . Also we will see how to deploy our angular application to azure using azure’s Web App Service. Step 1: Azure Subscription You would need to subscribe for azure portal in order to use azure services. Below is the link for azure portal – https://portal.azure.com/ If you do not have an Azure account, provide your email or telephone number and it will verify that you are not in the system and will invite you to create an account. There is an option for a free trial account with $200 USD in credits for 30 days, so you can play with Azure resources without spending money during those 30 days. Step 2: Create a resource Once you are subscribed on azure , you can go to “Create a resource” link and search for Web App. Click on Create web app and you will see the form as below – Creating Web App resource These details are required while creating web app service. You need to select a windows operating system for creating resource. Once all the configuration is done you can just review & create the resource. After resource is created , you can go to all resources tab and can see these two resources created – All resources First resource is an App Service where our angular application will be deployed . Second is application insights where you can monitor performance of your application. Step 3: Resource Configuration Here you can do the configuration for the resource created in step above. Create resource configuration page Step 4: Deploy application Now build your angular application using below command – ng build –prod This will create an deployable artifacts under /dist folder . You have to copy this content for hosting it on cloud . To copy the content go to “Advanced Tools” menu and click “Go” – Kudu services page will open as below – This gives us and FTP services to copy our deployment artifacts generated after build process. Now go to Debug Console -> CMD . We have to drag and drop the contents created in build step under sites/wwwroot folder on kudu services . Step 5: Configure Path under configuration Now edit the path to direct to your application folder uploaded in kudu service and click save- Path addition Now your application is up and running . You can see the link for your application on resource overview page as below –... Read more...Securing Angular 7 application with Spring Boot JWT SecuritySeptember 24, 2019Angular / Spring SecurityAs we have secured our angular application using spring boot basic security. In this article , i will take you through all the steps to secure your angular application with spring boot JWT(JSON Web Token) security. Using Spring boot basic security , we can provide in token based authentication and authorization to our application. We need to configure users and their roles in in separate configuration file. We are creating two projects here – Spring boot JWT security application – This will handle the authentication and authorization for our UI application. UI for Todo manager in angular – This is the Todo manager application which will leverage the spring boot security feature. Part 1: Spring boot JWT security application In this part , we will be creating a spring boot application which provides JWT security. Its basically a RESTful webservice which has endpoints to access and modify Todos information. To access the Todo information through API , user needs to authenticate himself. Below configuration enables basic security. SecurityConfig.java package com.myjavablog.config; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.HttpMethod; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.config.http.SessionCreationPolicy; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint; @Autowired private UserDetailsService jwtUserDetailsService; @Autowired private JwtRequestFilter jwtRequestFilter; @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { // configure AuthenticationManager so that it knows from where to load // user for matching credentials // Use BCryptPasswordEncoder auth.userDetailsService(jwtUserDetailsService).passwordEncoder(passwordEncoder()); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Bean @Override public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } @Override protected void configure(HttpSecurity httpSecurity) throws Exception { // We don't need CSRF for this example httpSecurity.csrf().disable() // dont authenticate this particular request .authorizeRequests().antMatchers("/authenticate").permitAll().antMatchers(HttpMethod.OPTIONS, "/**") .permitAll(). // all other requests need to be authenticated anyRequest().authenticated().and(). // make sure we use stateless session; session won't be used to // store user's state. exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and().sessionManagement() .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // Add a filter to validate the tokens with every request httpSecurity.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class); } } JwtAuthenticationController.java Below is JwtAuthenticationController.java which has API endpoint to authenticate the user and provides us with JWT. createAuthenticationToken() method validates the user and generated the token for us which has expiration of 5*60*60 (5 Hours). package com.myjavablog.controller; import java.util.Objects; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.BadCredentialsException; import org.springframework.security.authentication.DisabledException; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import com.myjavablog.config.JwtTokenUtil; import com.myjavablog.model.JwtRequest; import com.myjavablog.model.JwtResponse; @RestController @CrossOrigin public class JwtAuthenticationController { @Autowired private AuthenticationManager authenticationManager; @Autowired private JwtTokenUtil jwtTokenUtil; @Autowired private UserDetailsService jwtInMemoryUserDetailsService; @RequestMapping(value = "/authenticate", method = RequestMethod.POST) public ResponseEntity<?> createAuthenticationToken(@RequestBody JwtRequest authenticationRequest) throws Exception { authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword()); final UserDetails userDetails = jwtInMemoryUserDetailsService .loadUserByUsername(authenticationRequest.getUsername()); final String token = jwtTokenUtil.generateToken(userDetails); return ResponseEntity.ok(new JwtResponse(token)); } private void authenticate(String username, String password) throws Exception { Objects.requireNonNull(username); Objects.requireNonNull(password); try { authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password)); } catch (DisabledException e) { throw new Exception("USER_DISABLED", e); } catch (BadCredentialsException e) { throw new Exception("INVALID_CREDENTIALS", e); } } } TodoController.java Below is the Rest controller class for managing Todo’s information – package com.myjavablog.controller; import com.myjavablog.model.Todo; import com.myjavablog.model.User; import com.myjavablog.repository.TodoRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.ArrayList; import java.util.List; @CrossOrigin(origins = "http://localhost:4200") @RestController @RequestMapping("/api") public class TodoController { //@Autowired //private TodoRepository todoRepository; static List<Todo> list = new ArrayList<>(); @GetMapping(produces = "application/json") @RequestMapping({ "/validateLogin" }) public User validateLogin() { return new User("User successfully authenticated"); } @GetMapping(produces = "application/json") @RequestMapping("/todos") public List<Todo> getTodos(){ return list; } TodoController(){ list.add(new Todo(1l,"Badminton", "Badminton at 6 am", "Pending")); list.add(new Todo(2l,"Cricket", "Cricket at 7 am", "Pending")); list.add(new Todo(3l,"Football", "Football at 8 am", "Pending")); list.add(new Todo(4l,"Cards", "Cards at 6 am", "Pending")); list.add(new Todo(5l,"TT", "TT at 6 am", "Completed")); list.add(new Todo(6l,"Golf", "Golf at 6 am", "Pending")); list.add(new Todo(7l,"Running", "Running at 6 am", "Pending")); list.add(new Todo(8l,"Walking", "Walking at 6 am", "Pending")); list.add(new Todo(9l,"Swimming", "Swimming at 6 am", "Completed")); list.add(new Todo(10l,"Reading", "Reading at 6 am", "Pending")); //return list; } @GetMapping("/todo/{id}") public Todo getTodo(@PathVariable Long id) { //return todoRepository.findById(id); for(Todo todo : list){ if(todo.getId() == id){ return todo; } } return null; } @DeleteMapping("/todo/{id}") public boolean deleteTodo(@PathVariable Long id){ //todoRepository.deleteById(id); for(Todo todo : list){ if(todo.getId() == id){ list.remove(todo); } } return true; } @PostMapping("/todo") public Todo createTodo(@RequestBody Todo todo){ list.add(todo); return todo; //return todoRepository.save(todo); } @PutMapping("/todo") public Todo updateTodo(@RequestBody Todo todo){ for(Todo t : list){ if(todo.getId() == t.getId()){ list.remove(t); list.add(todo); return todo; } } return null; //return todoRepository.save(todo); } } JwtTokenUtil.java – This class is responsible for token generation. JwtRequestFilter.java – All request to REST API are filtered through this class. Token is validated in each request for user authorization. We can call the webservice through POSTMAN as below – Get the Authentication Token Call to todo API using Authentication token Source code can be downloaded from below link – Download Part 2: UI for Todo manager in angular 7 All the REST service calls are authenticated and authorized using the spring boot JWT security. Before calling todo services , we need to pass authorization header with all requests from UI. In JWT token based security , we pass on base 64 encoded string of username and password to server as authorization header in below format – Authorization Header = “Bearer ” + Base64Encoder(username:password) Step 1: Create new angular application Refer below post for creating new angular application – Angular Installation and Setup Step 2: Create modules for material and primeng components Create two modules for material(material.module.ts) and primeng( primeng.module.ts ) to define all the related components required in application. These two modules are also required to be imported in main module (app.module.ts) Please refer below link for primeng and material configuration – CRUD Operations using primeng datatable and Material Design Step 3: Create components (Presentation layer) Create components named header, footer, login,logout and todo components for Todo Manager application. Todo manager application shows all todos in primeng datatable . Also we are allowed to perform CRUD operations on all todos. All CRUD operations are done in todo component as below – Todo component – components\todo\todo.component.html components\todo\todo.component.ts Step 4: Add the routing for application (Application Navigation/Routing) We have to create a route for the application navigation. Below file contains routing configuration – src\app\app-routing.module.ts import { NgModule, ViewChildren } from '@angular/core'; import { Routes, RouterModule } from '@angular/router'; import { TodoComponent } from './components/todo/todo.component'; import { TodoAddComponent } from './components/todo-add/todo-add.component'; import { TodoEditComponent } from './components/todo-edit/todo-edit.component'; import { AuthGaurdService } from './services/auth-gaurd.service'; import { LogoutComponent } from './components/logout/logout.component'; import { LoginComponent } from './components/login/login.component'; const routes: Routes = }, { path: 'todo-add', component: TodoAddComponent ,canActivate: }, { path: 'todo-edit/:id', component: TodoEditComponent ,canActivate:}, { path: '', component: TodoComponent,canActivate: }, { path: 'login', component: LoginComponent }, { path: 'logout', component: LogoutComponent,canActivate: } ]; @NgModule({ imports: , exports: }) export class AppRoutingModule { } All the routes are guarded by auth guard service. AuthGuardService checks ,if user is logged in to the application and then only it activates those routes configured in app-routing.module.ts . AuthGuardService has canActivate() method which returns true if user is already logged into the application. If user is not logged into the application then it returns false and redirect him to login page. import { Injectable } from '@angular/core'; import { Router, ActivatedRouteSnapshot, RouterStateSnapshot, CanActivate } from '@angular/router'; import { AuthenticationService } from './authentication.service'; @Injectable({ providedIn: 'root' }) export class AuthGaurdService implements CanActivate { constructor(private router: Router, private authService: AuthenticationService) { } canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) { if (this.authService.isUserLoggedIn()) return true; this.router.navigate(); return false; } } Step 5: Authentication and Todo service (Service Layer) AuthenticationService (authentication.service.ts) – It handles user authentication into the application. It has authenticate( username, password ) method which receives username and password entered on login page and authenticate user using spring basic authentication method. Whenever you hit webservice , SecurityConfig.java comes into picture. If you remember, we have configured JWT security in spring boot application created earlier . When we hit todo service then every the time we are authenticated against spring boot JWT security. We need to pass authorization header all the time while hitting webservice from UI. Authorization header contains user credentials and JSON Web Token which has some expiry value upto which we can make request to TODO API. Also it stores user information in session for checking user logged in status. import { Injectable } from '@angular/core'; import { HttpClient, HttpHeaders } from '@angular/common/http'; import { map } from 'rxjs/operators'; export class User{ constructor( public status:string, ) {} } export class JwtResponse{ constructor( public jwttoken:string, ) {} } @Injectable({ providedIn: 'root' }) export class AuthenticationService { constructor(private httpClient: HttpClient){ } authenticate(username, password) { return this.httpClient.post<any>('http://localhost:8081/authenticate',{username,password}).pipe( map( userData => { sessionStorage.setItem('username',username); let tokenStr= 'Bearer '+userData.token; sessionStorage.setItem('token', tokenStr); return userData; } ) ); } isUserLoggedIn() { let user = sessionStorage.getItem('username') console.log('Is User Logged in: '+ !(user === null)) return !(user === null) } logOut() { sessionStorage.removeItem('username') } } We also have TodoService (todo.service.ts) to perform various operations on Todo information. import { Injectable } from '@angular/core'; import { HttpClient, HttpHeaders } from '@angular/common/http'; import { Observable, of, throwError } from 'rxjs'; import { map, catchError, tap, retry } from 'rxjs/operators'; import { Todo } from './../domain/Todo'; @Injectable({ providedIn: 'root' }) export class TodoService { endpoint = 'http://localhost:8081/api'; username = 'myjavablog'; password = 'password'; constructor(private httpClient: HttpClient) { } // Http Options httpOptions = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) } public deleteTodo(todoId) { const headers = new HttpHeaders({ Authorization: 'Bearer ' + btoa(this.username + ':' + this.password) }); return this.httpClient.delete<Todo>("http://localhost:8081/api/todo" + "/" + todoId, { headers }); } public createTodo(todo) { const headers = new HttpHeaders({ Authorization: 'Bearer ' + btoa(this.username + ':' + this.password) }); return this.httpClient.post<Todo>("http://localhost:8081/api/todo", todo, { headers }); } // To Get List Of Todos getTodoList(): Observable<any> { const headers = new HttpHeaders({ Authorization: 'Bearer ' + btoa(this.username + ':' + this.password) }); return this.httpClient.get<Todo[]>('http://localhost:8081/api/todos', { headers }); } // HttpClient API get() method => Fetch Todo getTodo(id): Observable<Todo> { const headers = new HttpHeaders({ Authorization: 'Bearer ' + btoa(this.username + ':' + this.password) }); return this.httpClient.get<Todo>(this.endpoint + '/todos/' + id, { headers }); } // HttpClient API put() method => Update Todo updateTodo(id, todo): Observable<Todo> { const headers = new HttpHeaders({ Authorization: 'Bearer ' + btoa(this.username + ':' + this.password) }); return this.httpClient.put<Todo>(this.endpoint + '/todo' , JSON.stringify(todo), { headers }); } } You can download source code for this application from below link – Download Step 6: Run the application ng serve Login page Login page Home page Home Page Generated Token during login Add todo – Add Todo... Read more...Securing Angular 7 application with Spring Boot Basic SecuritySeptember 15, 2019Angular / Spring SecurityWe need to configure users and their roles in in separate configuration file. We are creating two projects here – In this article , i will take you through all the steps to secure your angular application with spring boot basic security. Using Spring boot basic security , we can provide in memory authentication and authorization to our application. Spring boot basic security application – This will handle the authentication and authorization for our UI application. UI for Todo manager in angular – This is the Todo manager application which will leverage the basic spring boot security feature. Part 1: Spring boot basic security application In this part , we will be creating a simple spring boot application which provides basic security. Its basically a RESTful webservice which has endpoints to access and modify Todos information. To access the Todo information through API , user needs to authenticate himself. Below configuration enables basic security. SecurityConfig.java package com.myjavablog; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.http.HttpMethod; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable(). authorizeRequests().antMatchers(HttpMethod.OPTIONS, "/**").permitAll().anyRequest().authenticated() .and().httpBasic(); } @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication().withUser("myjavablog").password("{noop}secure").roles("USER"); } } Below is the Rest controller class (TodoController.java)- package com.myjavablog.controller; import com.myjavablog.model.Todo; import com.myjavablog.model.User; import com.myjavablog.repository.TodoRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.ArrayList; import java.util.List; @CrossOrigin(origins = "http://localhost:4200") @RestController @RequestMapping("/api") public class TodoController { //@Autowired //private TodoRepository todoRepository; static List<Todo> list = new ArrayList<>(); @GetMapping(produces = "application/json") @RequestMapping({ "/validateLogin" }) public User validateLogin() { return new User("User successfully authenticated"); } @GetMapping(produces = "application/json") @RequestMapping("/todos") public List<Todo> getTodos(){ return list; } TodoController(){ list.add(new Todo(1l,"Badminton", "Badminton at 6 am", "Pending")); list.add(new Todo(2l,"Cricket", "Cricket at 7 am", "Pending")); list.add(new Todo(3l,"Football", "Football at 8 am", "Pending")); list.add(new Todo(4l,"Cards", "Cards at 6 am", "Pending")); list.add(new Todo(5l,"TT", "TT at 6 am", "Completed")); list.add(new Todo(6l,"Golf", "Golf at 6 am", "Pending")); list.add(new Todo(7l,"Running", "Running at 6 am", "Pending")); list.add(new Todo(8l,"Walking", "Walking at 6 am", "Pending")); list.add(new Todo(9l,"Swimming", "Swimming at 6 am", "Completed")); list.add(new Todo(10l,"Reading", "Reading at 6 am", "Pending")); //return list; } @GetMapping("/todo/{id}") public Todo getTodo(@PathVariable Long id) { //return todoRepository.findById(id); for(Todo todo : list){ if(todo.getId() == id){ return todo; } } return null; } @DeleteMapping("/todo/{id}") public boolean deleteTodo(@PathVariable Long id){ //todoRepository.deleteById(id); for(Todo todo : list){ if(todo.getId() == id){ list.remove(todo); } } return true; } @PostMapping("/todo") public Todo createTodo(@RequestBody Todo todo){ list.add(todo); return todo; //return todoRepository.save(todo); } @PutMapping("/todo") public Todo updateTodo(@RequestBody Todo todo){ for(Todo t : list){ if(todo.getId() == t.getId()){ list.remove(t); list.add(todo); return todo; } } return null; //return todoRepository.save(todo); } } Source code can be downloaded from below link – Download Part 2: UI for Todo manager in angular 7 All the REST service calls are authenticated and authorized using the spring boot basic security. Before calling todo services , we need to pass authorization header with all requests from UI. All our requests to REST calls are intercepted encoded by base 64 encoding and then passed to REST API. In basic security we pass on base 64 encoded string of username and password to server as authorization header in below format – Authorization Header = “Basic” + Base64Encoder(username:password) Step 1: Create new angular application Refer below post for creating new angular application – Angular Installation and Setup Step 2: Create modules for material and primeng components Create two modules for material(material.module.ts) and primeng( primeng.module.ts ) to define all the related components required in application. These two modules are also required to be imported in main module (app.module.ts) Please refer below link for primeng and material configuration – CRUD Operations using primeng datatable and Material Design Step 3: Create components (Presentation layer) Create components named header, footer, login,logout and todo components for Todo Manager application. Todo manager application shows all todos in primeng datatable . Also we are allowed to perform CRUD operations on all todos. All CRUD operations are done in todo component as below – Todo component – components\todo\todo.component.html components\todo\todo.component.ts Step 4: Add the routing for application (Application Navigation/Routing) We have to create a route for the application navigation. Below file contains routing configuration – src\app\app-routing.module.ts import { NgModule, ViewChildren } from '@angular/core'; import { Routes, RouterModule } from '@angular/router'; import { TodoComponent } from './components/todo/todo.component'; import { TodoAddComponent } from './components/todo-add/todo-add.component'; import { TodoEditComponent } from './components/todo-edit/todo-edit.component'; import { AuthGaurdService } from './services/auth-gaurd.service'; import { LogoutComponent } from './components/logout/logout.component'; import { LoginComponent } from './components/login/login.component'; const routes: Routes = }, { path: 'todo-add', component: TodoAddComponent ,canActivate: }, { path: 'todo-edit/:id', component: TodoEditComponent ,canActivate:}, { path: '', component: TodoComponent,canActivate: }, { path: 'login', component: LoginComponent }, { path: 'logout', component: LogoutComponent,canActivate: } ]; @NgModule({ imports: , exports: }) export class AppRoutingModule { } All the routes are guarded by auth guard service. AuthGuardService checks ,if user is logged in to the application and then only it activates those routes configured in app-routing.module.ts . AuthGuardService has canActivate() method which returns true if user is already logged into the application. If user is not logged into the application then it returns false and redirect him to login page. import { Injectable } from '@angular/core'; import { Router, ActivatedRouteSnapshot, RouterStateSnapshot, CanActivate } from '@angular/router'; import { AuthenticationService } from './authentication.service'; @Injectable({ providedIn: 'root' }) export class AuthGaurdService implements CanActivate { constructor(private router: Router, private authService: AuthenticationService) { } canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) { if (this.authService.isUserLoggedIn()) return true; this.router.navigate(); return false; } } Step 5: Authentication and Todo service (Service Layer) AuthenticationService (authentication.service.ts) – It handles user authentication into the application. It has authenticate( username, password ) method which receives username and password entered on login page and authenticate user using spring basic authentication method. Whenever you hit webservice , SecurityConfig.java comes into picture. If you remember, we have configured basic security in spring boot application created earlier . When we hit todo service then all the time we are authenticated against spring boot basic security. We need to pass authorization header all the time while hitting webservice from UI. Also it stores user information in session for checking user logged in status. import { Injectable } from '@angular/core'; import { HttpClient, HttpHeaders } from '@angular/common/http'; import { map } from 'rxjs/operators'; export class User { constructor( public status: string, ) { } } @Injectable({ providedIn: 'root' }) export class AuthenticationService { constructor(private httpClient: HttpClient){ } authenticate(username, password) { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(username + ':' + password) }); return this.httpClient.get<User>('http://localhost:8081/api/validateLogin', { headers }).pipe( map( userData => { sessionStorage.setItem('username', username); return userData; } ) ); } isUserLoggedIn() { let user = sessionStorage.getItem('username') console.log(!(user === null)) return !(user === null) } logOut() { sessionStorage.removeItem('username') } } We also have TodoService (todo.service.ts) to perform various operations on Todo information. import { Injectable } from '@angular/core'; import { HttpClient, HttpHeaders } from '@angular/common/http'; import { Observable, of, throwError } from 'rxjs'; import { map, catchError, tap, retry } from 'rxjs/operators'; import { Todo } from './../domain/Todo'; @Injectable({ providedIn: 'root' }) export class TodoService { endpoint = 'http://localhost:8081/api'; username = 'myjavablog'; password = 'secure'; constructor(private httpClient: HttpClient) { } // Http Options httpOptions = { headers: new HttpHeaders({ 'Content-Type': 'application/json' }) } public deleteTodo(todoId) { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(this.username + ':' + this.password) }); return this.httpClient.delete<Todo>("http://localhost:8081/api/todo" + "/" + todoId, { headers }); } public createTodo(todo) { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(this.username + ':' + this.password) }); return this.httpClient.post<Todo>("http://localhost:8081/api/todo", todo, { headers }); } // To Get List Of Todos getTodoList(): Observable<any> { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(this.username + ':' + this.password) }); return this.httpClient.get<Todo[]>('http://localhost:8081/api/todos', { headers }); } // HttpClient API get() method => Fetch Todo getTodo(id): Observable<Todo> { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(this.username + ':' + this.password) }); return this.httpClient.get<Todo>(this.endpoint + '/todos/' + id, { headers }); } // HttpClient API put() method => Update Todo updateTodo(id, todo): Observable<Todo> { const headers = new HttpHeaders({ Authorization: 'Basic ' + btoa(this.username + ':' + this.password) }); return this.httpClient.put<Todo>(this.endpoint + '/todo' , JSON.stringify(todo), { headers }); } } You can download source code for this application from below link – Download Step 6: Run the application ng serve Login page Home page Add todo –... Read more...Angular Forms – Template Driven and ReactiveJuly 28, 2019AngularForms are the mainstay of business applications. You use forms to log in, submit a help request, place an order, book a flight, schedule a meeting, and perform countless other data-entry tasks. Improve overall data quality by validating user input for accuracy and completeness. Code for this example can be downloaded from below links – Download There are two types of forms in Angular. Template Driven FormsReactive Forms Template Driven Forms In this kind of form, we can write the forms in Angular template syntax with form syntax directives. Following are the steps to build template driven forms. Create the component that controls the form.Create a template with the initial form layout.Bind data properties to each form control using the two-way data-binding syntax.Add an attribute to each form-input control.Add custom CSS to provide visual feedback.Show and hide validation-error messages.Handle form submission with ngSubmit.Disable the form’s Submit button until the form is valid. Reactive Forms We have used Reactive Forms to add Todo’s in our example in previous article. Reactive forms is an Angular technique for creating forms in a reactive style. Angular reactive forms facilitate a reactive style of programming that favors explicit management of the data flowing between a non-UI data model (typically retrieved from a server) and a UI-oriented form model that retains the states and values of the HTML controls on the screen. Reactive forms offer the ease of using reactive patterns, testing, and validation. In continuation with previous post on CRUD operations, we had created a form to add Todo’s into the system. There we used reactive forms as shown below – todo-add.component.html Please enter Task name Please enter Description Status Pending Cancelled Done Please enter status Submit First, we need to import some of the modules from the @angular/forms. FormGroup – This groups the form elements and access their values.FormBuilder – We have used form builder to handle all the validation. Validators – Assigns Validation rules to the Form Object. Also, we need have imported ReactiveFormsModule in app.module.ts file. todo-add.component.ts import { Component, OnInit, Output, EventEmitter, Input } from ‘@angular/core’; import { FormBuilder, Validators, FormGroup } from ‘@angular/forms’; import { Router } from ‘@angular/router’; import { TodoService } from ‘./../../services/todo.service’; import { NotifierService } from ‘angular-notifier’; @Component({ selector: ‘todo-add’, templateUrl: ‘./todo-add.component.html’, styleUrls: [‘./todo-add.component.css’] }) export class TodoAddComponent implements OnInit { formGroup: FormGroup; @Output() valueChange = new EventEmitter(); displayAddTodo: boolean; @Input() todo = { name: ”, desc: ”, status: ” }; constructor(private formBuilder: FormBuilder, private router: Router, private todoService: TodoService, private notifier: NotifierService) { } ngOnInit() { this.displayAddTodo = true; this.initializeTodoForm(); } addTodo() { if (this.formGroup.valid) { let todo = this.formGroup.value; console.log(“Todo data ” + todo); this.todoService.createTodo(todo).subscribe((data: {}) => { //this.router.navigate([‘/todo-list’]); this.notifier.notify(“success”,”Todo added successfully”); }) } } initializeTodoForm() { this.formGroup = this.formBuilder.group({ name: ], desc: ], status: ] }); } goBack(): void { this.displayAddTodo = false; console.log(“Back clicked= ” + this.displayAddTodo); this.valueChange.emit(this.displayAddTodo); } } We have used form builder (private formBuilder: FormBuilder) to handle all the validation. So in that constructor, we are creating a form with the validation rules. formGroup: FormGroup – This object is used to access form elements .... Read more...Consuming Restful API in angularJuly 28, 2019AngularIn continuation to our previous example on CRUD Operations using primeng datatable and Material Design, we will now look at how to call REST APIs using angular. Step 1: REST API We have our REST API developed using java. Below is the code which exposes TODO services to end users. It supports GET,POST,PUT,DELETE operations on resources. package com.myjavablog.controller; import com.myjavablog.entity.Todo; import com.myjavablog.entity.User; import com.myjavablog.repository.TodoRepository; import com.myjavablog.repository.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Optional; @CrossOrigin @RestController @RequestMapping(“/api”) public class TodoController { @Autowired private TodoRepository todoRepository; @GetMapping(“/todos”) public List getTodos(){ return todoRepository.findAll(); } @GetMapping(“/todo/{id}”) public Optional getTodo(@PathVariable Long id){ return todoRepository.findById(id); } @DeleteMapping(“/todo/{id}”) public boolean deleteTodo(@PathVariable Long id){ todoRepository.deleteById(id); return true; } @PostMapping(“/todo”) public Todo createTodo(@RequestBody Todo todo){ return todoRepository.save(todo); } @PutMapping(“/todo”) public Todo updateTodo(@RequestBody Todo todo){ return todoRepository.save(todo); } } Entire code for this Todo REST API can be downloaded from below github link – Download Step 2: How to call REST API from Angular As we have seen in my previous post , we have written a service in angular to call the REST api’s . Below is the code to call the REST API from angular- import { Injectable } from ‘@angular/core’; import { HttpClient, HttpHeaders } from ‘@angular/common/http’; import { Observable, of, throwError } from ‘rxjs’; import { map, catchError, tap, retry } from ‘rxjs/operators’; import { Todo } from ‘./../domain/Todo’; @Injectable({ providedIn: ‘root’ }) export class TodoService { endpoint = ‘http://localhost:8081/api’; constructor(private http: HttpClient) { } // Http Options httpOptions = { headers: new HttpHeaders({ ‘Content-Type’: ‘application/json’ }) } // To Get List Of Todos getTodoList(): Observable { return this.http.get(this.endpoint + ‘/todos’) .pipe( retry(1), catchError(this.handleError) ); } // HttpClient API get() method => Fetch Todo getTodo(id): Observable { return this.http.get(this.endpoint + ‘/todos/’ + id) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API post() method => Create Todo createTodo(todo): Observable { return this.http.post(this.endpoint + ‘/todo’, JSON.stringify(todo), this.httpOptions) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API put() method => Update Todo updateTodo(id, todo): Observable { return this.http.put(this.endpoint + ‘/todo’ , JSON.stringify(todo), this.httpOptions) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API delete() method => Delete Todo deleteTodo(id):Observable { console.log(“Delete id “+ id); return this.http.delete(this.endpoint+ ‘/todo/’ + id); } // Error handling handleError(error) { let errorMessage = ”; if (error.error instanceof ErrorEvent) { // Get client-side error errorMessage = error.error.message; } else { // Get server-side error errorMessage = `Error Code: ${error.status}\nMessage: ${error.message}`; } window.alert(errorMessage); return throwError(errorMessage); } } We are injecting private http: HttpClient object which is required to make REST API calls. I have hosted REST api on endpoint = ‘http://localhost:8081/api’ , now this endpoint is used to make all rest calls. Here for all REST calls ,we are returning Observable objects. These methods are getting called from components where these returned objects gets subscribed.Below is the component from which this TodoService is getting called – import { Component, OnInit } from ‘@angular/core’; import { TodoService } from ‘src/app/services/todo.service’; import { Router } from ‘@angular/router’; import { map, catchError, tap, retry } from ‘rxjs/operators’; import { NotifierService } from ‘angular-notifier’; import { Todo } from ‘src/app/domain/Todo’; import { SelectItem } from ‘primeng/primeng’; @Component({ selector: ‘todo-list’, templateUrl: ‘./todo.component.html’, styleUrls: [‘./todo.component.css’] }) export class TodoComponent implements OnInit { cols: any[]; todos: Todo[]; displayedColumns: string[] = ; displayTodoList = true; displayTodoAdd = false; displayTodoEdit = false; constructor(private todoService: TodoService, private router: Router, private notifier: NotifierService) { } ngOnInit() { this.displayTodoList = true; this.displayTodoAdd = false; this.displayTodoEdit = false; console.log(“From Init = ” + this.displayTodoList + ” ” + this.displayTodoAdd); this.getTodoList().subscribe((data) => { this.todos = data }); this.cols = ; this.statusValues = ; } // To Get List Of Todos getTodoList() { return this.todoService.getTodoList(); } // To Get Todo getTodo(todoId) { return this.todoService.getTodo(todoId); } // To Edit Todo editTodo(todoId) { this.displayTodoList = false; this.displayTodoEdit = true; this.router.navigate([`/todo-edit/${todoId}`]); } //Delete Todo deleteTodo(todoId) { console.log(“Delete id” + todoId); this.todoService.deleteTodo(todoId).subscribe((data) => { console.log(“success”); this.notifier.notify(“success”, “Task deleted successfully!!”); }); this.ngOnInit(); this.router.navigate([`/`]); } //add Todo addTodo() { console.log(“Before = ” + this.displayTodoList + ” ” + this.displayTodoAdd); this.displayTodoList = false; this.displayTodoAdd = true; console.log(“After =” + this.displayTodoList + ” ” + this.displayTodoAdd); } hideTodoAdd(event) { console.log(“Event emiited ” + event); this.displayTodoList = true; this.displayTodoAdd = event; } clonedTodos: { : Todo; } = {}; statusValues: SelectItem[]; onRowEditInit(todo: Todo) { this.clonedTodos = { …todo }; } onRowEditSave(todo: Todo) { this.todoService.updateTodo(todo.id, todo).subscribe((data) => { console.log(“success”); this.notifier.notify(“success”, “Task updated successfully!!”); }); } onRowEditCancel(todo: Todo, index: number) { this.todos = this.clonedTodos; delete this.clonedTodos; } } We have injected private todoService: TodoService via constructor and called its methods from TodoComponent . What is observable and subscriber? Observables – They provide support for passing messages between publishers and subscribers in your application. Observables offer significant benefits over other techniques for event handling, asynchronous programming, and handling multiple values. Observables are declarative—that is, you define a function for publishing values, but it is not executed until a consumer subscribes to it. The subscribed consumer then receives notifications until the function completes, or until they unsubscribe. // To Get List Of Todos getTodoList(): Observable { return this.http.get(this.endpoint + ‘/todos’) .pipe( retry(1), catchError(this.handleError) ); } Subscribe – As a publisher, you create an Observable instance that defines a subscriber function. This is the function that is executed when a consumer calls the subscribe() method. The subscriber function defines how to obtain or generate values or messages to be published. To execute the observable you have created and begin receiving notifications, you call its subscribe() method, passing an observer. This is a JavaScript object that defines the handlers for the notifications you receive. The subscribe() call returns a Subscription object that has an unsubscribe() method, which you call to stop receiving notifications. this.getTodoList().subscribe((data) => { this.todos = data }); Code for this example can be downloaded from below links – Download... Read more...CRUD Operations using primeng datatable and Material DesignJuly 28, 2019AngularIn this post , we are going to use PrimeNG which provides rich set of open source native Angular UI components and Angular Material Design components. Using these two UI libraries , we will built a application to perform CRUD operations. Code for this example can be downloaded from below links – Front End Code – Download Backend Code – Download Step 1: Install primeng https://www.primefaces.org/primeng/#/setup This package provides us lot of inbuilt UI components to design the User interface as per our requirements. We have created CustomPrimengModule which will have all the primeng components dependencies defined in it. We are using these primeng modules by importing CustomPrimengModule in main app module i.e. aap.module.ts file. Step 2: Install Angular material https://material.angular.io/guide/getting-started Angular Material is a UI component library forAngular JS developers by google. Angular Material components help in constructing attractive, consistent, and functional web pages and web applications while adhering to modern web design principles like browser portability, device independence, and graceful degradation. I have created CustomMaterialModule which will have all the material components dependencies defined in it. We are using these primeng modules by importing CustomMaterialModule in main app module i.e. aap.module.ts file. Also we need to make one entry for importing styles for material design theme – @import “../node_modules/@angular/material/prebuilt-themes/deeppurple-amber.css”; Step 3: Define Reactive forms module I have also defined ReactiveFormsModule and AppRoutingModule which are required for creating forms and routing. Step 4: Install App notifications Module https://www.npmjs.com/package/angular-notifier We are also using NotifierModule to show the notifications in application. For this , we need to import NotifierModule in app.module.ts. Also we need to make one entry for importing styles for notifications – @import “~angular-notifier/styles”; Step 5 : Create the components/Services/Models required for application Components: ng g c components/todo –main=app ng g c components/todo-add –main=app ng g c components/todo-edit –main=app Services: ng g s services/todo Model: Create a typescript file Todo.ts Step 6: Write the component to perform CRUD operations src\app\components\todo\todo.component.html – This is the view part which displays primeng data table providing features for sorting, pagination,inline row editing, Delete, Add row etc. List of Todo Tasks {{col.header}} {{todo.name}} {{todo.desc}} {{todo.status}} There are {{todos?.length}} todo tasks src\app\components\todo\todo.component.ts – This is a typescript file which has implementation for CRUD operations on primeng datatable. It uses TodoService to perform CRUD operations on data using REST webservice – import { Component, OnInit } from ‘@angular/core’; import { TodoService } from ‘src/app/services/todo.service’; import { Router } from ‘@angular/router’; import { map, catchError, tap, retry } from ‘rxjs/operators’; import { NotifierService } from ‘angular-notifier’; import { Todo } from ‘src/app/domain/Todo’; import { SelectItem } from ‘primeng/primeng’; @Component({ selector: ‘todo-list’, templateUrl: ‘./todo.component.html’, styleUrls: [‘./todo.component.css’] }) export class TodoComponent implements OnInit { cols: any[]; todos: Todo[]; displayedColumns: string[] = ; displayTodoList = true; displayTodoAdd = false; displayTodoEdit = false; constructor(private todoService: TodoService, private router: Router, private notifier: NotifierService) { } ngOnInit() { this.displayTodoList = true; this.displayTodoAdd = false; this.displayTodoEdit = false; console.log(“From Init = ” + this.displayTodoList + ” ” + this.displayTodoAdd); this.getTodoList().subscribe((data) => { this.todos = data }); this.cols = ; this.statusValues = ; } // To Get List Of Todos getTodoList() { return this.todoService.getTodoList(); } // To Get Todo getTodo(todoId) { return this.todoService.getTodo(todoId); } // To Edit Todo editTodo(todoId) { this.displayTodoList = false; this.displayTodoEdit = true; this.router.navigate([`/todo-edit/${todoId}`]); } //Delete Todo deleteTodo(todoId) { console.log(“Delete id” + todoId); this.todoService.deleteTodo(todoId).subscribe((data) => { console.log(“success”); this.notifier.notify(“success”, “Task deleted successfully!!”); }); this.ngOnInit(); this.router.navigate([`/`]); } //add Todo addTodo() { console.log(“Before = ” + this.displayTodoList + ” ” + this.displayTodoAdd); this.displayTodoList = false; this.displayTodoAdd = true; console.log(“After =” + this.displayTodoList + ” ” + this.displayTodoAdd); } hideTodoAdd(event) { console.log(“Event emiited ” + event); this.displayTodoList = true; this.displayTodoAdd = event; } clonedTodos: { : Todo; } = {}; statusValues: SelectItem[]; onRowEditInit(todo: Todo) { this.clonedTodos = { …todo }; } onRowEditSave(todo: Todo) { this.todoService.updateTodo(todo.id, todo).subscribe((data) => { console.log(“success”); this.notifier.notify(“success”, “Task updated successfully!!”); }); } onRowEditCancel(todo: Todo, index: number) { this.todos = this.clonedTodos; delete this.clonedTodos; } } Step 7: Service Layer – We have injected TodoService through constructor and used it to perform CRUD operations .This service has GET,POST,PUT,DELETE calls to REST endpoints . src\app\services\todo.service.ts import { Injectable } from ‘@angular/core’; import { HttpClient, HttpHeaders } from ‘@angular/common/http’; import { Observable, of, throwError } from ‘rxjs’; import { map, catchError, tap, retry } from ‘rxjs/operators’; import { Todo } from ‘./../domain/Todo’; @Injectable({ providedIn: ‘root’ }) export class TodoService { endpoint = ‘http://localhost:8081/api’; constructor(private http: HttpClient) { } // Http Options httpOptions = { headers: new HttpHeaders({ ‘Content-Type’: ‘application/json’ }) } // To Get List Of Todos getTodoList(): Observable { return this.http.get(this.endpoint + ‘/todos’) .pipe( retry(1), catchError(this.handleError) ); } // HttpClient API get() method => Fetch Todo getTodo(id): Observable { return this.http.get(this.endpoint + ‘/todos/’ + id) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API post() method => Create Todo createTodo(todo): Observable { return this.http.post(this.endpoint + ‘/todo’, JSON.stringify(todo), this.httpOptions) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API put() method => Update Todo updateTodo(id, todo): Observable { return this.http.put(this.endpoint + ‘/todo’ , JSON.stringify(todo), this.httpOptions) .pipe( retry(1), catchError(this.handleError) ) } // HttpClient API delete() method => Delete Todo deleteTodo(id):Observable { console.log(“Delete id “+ id); return this.http.delete(this.endpoint+ ‘/todo/’ + id); } // Error handling handleError(error) { let errorMessage = ”; if (error.error instanceof ErrorEvent) { // Get client-side error errorMessage = error.error.message; } else { // Get server-side error errorMessage = `Error Code: ${error.status}\nMessage: ${error.message}`; } window.alert(errorMessage); return throwError(errorMessage); } } Step 8: Domain Layer – It contains model to hold the todo tasks data. export interface Todo { id?; name?; desc?; status?; } Step 9: Now we are ready to run the project – ng serve Step 10: Screenshots – Main page with data Grid Add Task screen Inline Task Editing screen Deleting task –... Read more...Angular 7 – CRUD OperationsApril 19, 2019AngularThis is very huge post which covers most of the angular concepts , so please be patient and go through it. This post is related to angular CRUD operations using angular AG grid and REST webservices in java. We will go through below concepts while going through these post – REST API in javaAG Grid in javaBootstrap Configuration Notifications service configurationReactive forms in angularForm ValidationsService in angularCalling REST API using HttpClientRouting and Navigation 1.REST API in java We would need to create a REST API which supports CRUD operations on user data as below – package com.myjavablog.controller; import com.myjavablog.entity.User; import com.myjavablog.repository.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Optional; @CrossOrigin @RestController @RequestMapping(“/api”) public class UserController { @Autowired private UserRepository userRepository; @GetMapping(“/users”) public List getUsers(){ return userRepository.findAll(); } @GetMapping(“/user/{id}”) public Optional getUser(@PathVariable Long id){ return userRepository.findById(id); } @DeleteMapping(“/user/{id}”) public boolean deleteUser(@PathVariable Long id){ userRepository.deleteById(id); return true; } @PostMapping(“/user”) public User createUser(@RequestBody User user){ return userRepository.save(user); } @PutMapping(“/user”) public User updateUser(@RequestBody User user){ return userRepository.save(user); } } This is the controller in java which supports GET,UPDATE,PUT,POST operations on USER data. You can download the entire code from below Github link – Download 2. AG Grid in java Before actually going into angular project, you can go through my older posts on how to create angular project. https://www.myjavablog.com/2019/04/13/angular-installation-and-setup/ Once the project is created you need to install ag-grid support to it. Below packages needs to be installed for the same – npm i –save ag-grid You need to import this dependency in app.module.ts by adding below line under imports – AgGridModule.withComponents(null) Also you need to add CSS support for grid in styles.css – @import ‘ag-grid-community/dist/styles/ag-grid.css’; @import ‘ag-grid-community/dist/styles/ag-theme-blue.css Then create a component using below command – ng n c user This will create new user component and create CSS, TS , html files. Add code to html file for grid – Angular 7 AG Grid CRUD Operations Example Add User Edit User Delete User All the options specified in grid configuration are self explanatory. You also need Typescript file in order to perform CRUD operations . You get this from my github link. 3. Bootstrap Configuration First install bootstrap by using below npm command – npm install bootstrap Then Add bootstrap to angular.json under styles- “styles”: [ “src/styles.css”, “node_modules/bootstrap/dist/css/bootstrap.min.css” ], 4. Notifications service configuration This service is to show the notifications to users. Use below npm command to install – npm install angular-notifier Add it into imports in app.module.ts and add custom options as well- NotifierModule.withConfig( customNotifierOptions ) /** * Custom angular notifier options */ const customNotifierOptions: NotifierOptions = { position: { horizontal: { position: ‘middle’, distance: 12 }, vertical: { position: ‘top’, distance: 12, gap: 10 } }, theme: ‘material’, behaviour: { autoHide: 5000, onClick: false, onMouseover: ‘pauseAutoHide’, showDismissButton: true, stacking: 4 }, animations: { enabled: true, show: { preset: ‘slide’, speed: 300, easing: ‘ease’ }, hide: { preset: ‘fade’, speed: 300, easing: ‘ease’, offset: 50 }, shift: { speed: 300, easing: ‘ease’ }, overlap: 150 } }; Also you would need to add CSS for notifier in app.component.html file as below – 5. Reactive forms in angular Now you need to create user form to add users – Add User First Name: First name is required Last Name: Last name is required Email address: Email is required Age: Age is required Mobile: Mobile number is required Submit Invalid credentials. Back 6. Form Validations With reactive forms ,you can associate FormGroup and FormBuilder and access the form fields . Using these objects , you can also validate the form fields using angular Validators. 7. Services in Angular We have to write the service to call the REST APIs and perform CRUD operations as below – Create service using – ng g s user import { Injectable } from ‘@angular/core’; import { User } from ‘./../model/user’; import {HttpClient} from ‘@angular/common/http’; @Injectable({ providedIn: ‘root’ }) export class UserService { apiUrl:string = “http://localhost:8081/api/”; constructor(private http : HttpClient) { } getUsers() { return this.http.get(this.apiUrl+’users’); } deleteUser(userId: number){ return this.http.delete(this.apiUrl+’user/’+userId); } addUser(user: User){ console.log(user); return this.http.post(this.apiUrl+ ‘user/’, user ); } editUser(user: User){ console.log(user); return this.http.put(this.apiUrl+ ‘user/’, user ); } } 8. Calling REST API using HttpClient In above service, we are injecting HttpClient in constructor to call the REST API. 9. Routing and Navigation We would need to provide routing for our application. So specific URI will be served by specific Component. Route configuration is provided in app-routing.module.ts as below – import { NgModule } from ‘@angular/core’; import { Routes, RouterModule } from ‘@angular/router’; import { LoginComponent } from ‘./components/login/login.component’; import { UserComponent } from ‘./components/user/user.component’; import { AddUserComponent } from ‘./components/user/add-user/add-user.component’; const routes: Routes = ; @NgModule({ imports: , exports: }) export class AppRoutingModule { } You can download the code for this application from below github link – Download Now build the application and serve it to the client – ng build ng serve Now the application is ready to access on http://localhost:4200/- Login screen Angular ag grid showing all users Add New User User Editing Updated last name and email User Deleted Form Validations... Read more...Angular DirectivesApril 14, 2019AngularThere are mainly two types of directives as below – Structural Directives Structural Directives are used for manipulating the DOM elements. You will find an asterisk (*) prefix before the directive. We can take*ngFor and *ngIf as examples here. Attribute Directives When it comes to altering the behavior and look of the DOM element, you turn to attribute directives. ngIf ngSwitchCase ngForngStylengClass... Read more...Angular History and AdvantagesApril 14, 2019AngularAngular JS is quite famous javascript framework. It evolved from Angular 1 to recently used Angular 7 version. Below is the detailed version evolution history of angular – Angular 1: AngularJS was released in 2010 by Google. Normally AngularJS is also referred as Angular1 by some people. So AngularJS is of version Angular 1.x. This is the only version of AngularJS. Everything was fine but development of ReactJS and its large impact on the world and also the fact it was from Facebook was quite intense. It led to competition between frameworks from two renowned companies. Angular 2: So to match the needs Google developed Angular2 which was released in 2016, a complete re-write of AngularJS from same the team which developed AngularJS . To avoid name confusion team went with the same name without JS part. And the difference between AngularJS 1.x and the new Angular was such that it was impossible to update from one to another. So only option was to migrate. Angular2 is based on service/controller model whereas AngularJS was using MVC model. Also it uses TypeScript to build the application in place of JavaScript. Angular 4: Then team developed Angular3 but it was skipped and Angular4 was introduced. Angular4 was introduced in 2017 which introduced some new features like Universal Project. Unlike AngularJS and Angular2, Angular4 is compatible with Angular2. This means it is a improved version of Angular2 and not a re-write. Angular4 provides many enhancements in comparison to Angular2. Some of these enhancements are inbuilt Animation Package, ngTemplate,Form Validator attributes , titlecase pipe etc. Angular 5: Then Angular5 was released but it was just updated version of Angular4. It has a bunch of additional features and bug fixes like Build Optimizer, HttpClient etc. Angular 6: Angular6 is the latest version of angular which was released in 2018. It focuses more on toolchain like with Angular in the future, like: ngAngular Elements, CLI Workspaces, Library Support, Angular Material Starter Components. So these are versions of Angular till date. Angular6 is much faster to its previous versions as it is using Ivy Rendered which is a rendering engine. Angular 7: The Angular 7 is escalated between Angular core frameworks, Angular Material a CLI. Angular CLI has now a convenient guide to walk through the creation of the applications. Angular 7 also introduced the concept of the “Bundle Budget” which helps in reducing the bundle size of an Angular app. Angular Material is a UI toolkit, which has modernized the homepage for guidance related to design, components and tooling around for building better user experiences. Angular CDK provides virtual scrolling capabilities with a drag & drop framework. Advantages Of using Angular – Two-way data binding – AngularJS was built with Model-View-Controller architecture. And the framework synchronized the Model and the View. As the data in the Model changes, the View does too. Two-way data binding allowed engineers to reduce development time as it didn’t require writing additional code to provide continual View and Model synchronization. Directives – This feature actually enabled the HTML extension mentioned above. Directives allowed developers to assign special behaviors to the Document Object Model (DOM), permitting engineers to create dynamic and rich content with HTML. Dependency injection – Dependencies define how different pieces of code interact with each other and how the changes in one component impact the other ones. Usually, dependencies are directly defined in components themselves. So that every change in dependency requires changing components as well. With AngularJS, you could use injectors that defined dependencies as external elements decoupling components from their dependencies. Dependency injection made components more reusable, easier to manage and test. Community – Right from the beginning, AngularJS became extremely popular among engineers. A strong community provided enough training materials, discussions, and third-party tools to embark on using AngularJS as well as find a solution to nearly every arising issue. Newer versions of angular i.e. Angular 2 plus has components based design as compared to angular 1 which followed MVC flow. Components based architecture provides high reusability of components across the Application. Great performance – Angular2 – doesn’t do deep object comparison. If items are added/removed to/from an array, change detection won’t detect it. The same for object properties as long as they are not directly bound from the view. Reusability – Components of a similar nature are well encapsulated, in other words, self-sufficient. Developers can reuse them across different parts of an application. This is particularly useful in enterprise-scope applications where different systems converge but may have many similar elements like search boxes, date pickers, sorting lists, etc. Readability – Encapsulation also ensures that new developers – who’ve been recently on boarded to a project – can read code better and eventually reach their plateau of productivity faster. Unit Test Friendly – The independent nature of components simplifies unit tests, quality assurance procedures aimed at verifying the performance of the smallest parts of the application units. Maintainability – Components that are easily decoupled from each other can be easily replaced with better implementations. Basically, your engineering team will be more efficient in maintaining and updating the code within the iterative development workflow. Usage of Typescript – The biggest selling point of TypeScript is tooling. It provides advanced autocompletion, navigation, and refactoring. Having such tools is almost a requirement for large projects.... Read more...Angular Installation and SetupApril 13, 2019AngularIn this post , we will see how to install angular environment and create & run first ever angular application – Prerequisites – You need to install node.js on your system. You can download node.js from their official website https://nodejs.org/en/ Once you install it on your system,you can check the version of node.js by executing below command on command line – node -v v10.15.0 With node.js installation ,you will by default get npm (Node Package Manager). NPM provides the libraries required to run the angular application. Below command gives the version of npm – npm -v 6.4.1 Now below are the steps to create,build & deploy your first angular application . Step 1: Install Angular CLI Angular CLI is Command Line Interface which provides various commands to create , build and deploy application . Below is npm command to install Angular CLI globally – npm install -g @angular/cli Step 2: Create a workspace anf first Anguar application ng new firstApp This will create a workspace for new project i.e. first-app . It will generate all the initial artifacts. Project structure is as below – src – All source filese2e – End to end test projectConfiguration files – angular.json, package.json etc. Step 3: Use of IDE I personally prefer, Visual Code Studio as IDE for angular project. Its an open source IDE provided by Microsoft. Step 4: Build and deploy ng build This command will build the project and create the artifacts in /dist folder. ng serve This command will deploy the build artifacts to nodejs server and serve it to client. Application can accessed via – http://localhost:4200/... Read more...Dockerizing angular applicationMarch 31, 2019Angular / DockerIn this post , we will dockerize a simple application designed in angular 7. Tools used – Docker Toolbox Visual Code Studio npm Steps required to dockerize the simple angular application are as below -Go to the folder where you want to create angular project Step 1: Go to the folder where you want to create angular project Step 2: You need to first install NodeJS and then angular CLI using below command – npm install -g @angular/cli Step 3: Once you install angular CLI package from node package manager, you will be able to execute angular commands on console. With below commands you can create new angular project and build it. Create new angular project – ng new angular-docker-demo Switch to newly created folder by cd angular-docker-demo You can run the angular project using belwo command – ng serve Running application can be access from – http://localhost:80/ Step 4: Now in this step , we will move towards dockerizing the application created in above steps. For that, you need to create docker file as below – FROM nginx:1.13.3-alpine ## Remove default code for nginx website RUN rm -rf /usr/share/nginx/html/* ## Copy all build artifacts in dist folder generated after building project into default nginx public folder COPY /dist /usr/share/nginx/html #Expose port 80 of container EXPOSE 80 CMD First line in docker file i.e. FROM nginx:1.13.3-alpine will download nginx server from docker hub. NGINX (Pronounced as Engine-X) is an open source, lightweight, high-performance web server or proxy server. We would need this server to host our application. Second line will remove default NGINX website code present under /usr/share/nginx/html/ folder. After we build our angular project ,build artifacts will be generated under /dist folder . Third line will copy contents of /dist under /usr/share/nginx/html/ folder and will serve this web content on browser. Step 5: Below commands will first build the angular application which is PROD ready. Then build the docker image and run that image. ng build –prod docker build -t angular-docker-demo. docker run -p 8082:80 –name angular-docker-demo angular-docker-demo... Read more...Spring Data JPA and Hibernate Interview QuestionsMarch 21, 2019Hibernate / InterviewIn this tutorial series, we will discuss most important concepts which may be asked in interviews. 1.What Is Java Persistence API? The Java Persistence API provides a specification for persisting, reading, and managing data from your Java object to relational tables in the database.Mapping Java objects to database tables and vice versa is called Object-relational mapping (ORM) . JPA is a specification and several implementations are available. Popular implementations are Hibernate, Spring Data JPA , Apache OpenJPA and Toplink . 2. What is Hibernate Framework? Hibernate ORM (Hibernate in short) is an object-relational mapping tool for the Java programming language. It provides a framework for mapping an object-oriented domain model to a relational database. Hibernate handles object-relational impedance mismatch problems by replacing direct, persistent database accesses with high-level object handling functions. Hibernate’s primary feature is mapping from Java classes to database tables, and mapping from Java data types to SQL data types. Hibernate also provides data query and retrieval facilities. It generates SQL calls and relieves the developer from the manual handling and object conversion of the result set. Hibernate provides reference implementation of Java Persistence API, that makes it a great choice as ORM tool with benefits of loose coupling. We can use Hibernate persistence API for CRUD operations. Hibernate framework provide option to map plain old java objects to traditional database tables with the use of JPA annotations as well as XML based configuration. 3. What are the benefits of using JPA framework in persistence layer? Elimination of boilerplate code which earlier being added for JDBC. These frameworks(Spring Data JPA and Hibernate) can be easily integrated into the applications.Provides support for caching thus improves the performance.It provides support for Native and Named queries so that we can write dynamic and complex queries.Easily configurable using XML or JPA annotations.Provides support for HQL same as SQL which has better performance. 4. What is the difference between SessionFactory and EntityManager ? EntityManager interface is similar to sessionFactory in hibernate. EntityManager is under javax.persistance package but session and sessionFactory under org.hibernate.Session/sessionFactory package. Entity manager is JPA specific and session/sessionFactory are hibernate specific. EntityManager @PersistenceContext EntityManager entityManager; public List<MyEntity> findById() { return entityManager .createQuery("from MyEntity where apples=7", MyEntity.class) .getResultList(); } SessionFactory @Autowired SessionFactory sessionFactory; public List<MyEntity> findById() { Session session = sessionFactory.getCurrentSession(); List<?> result = session.createQuery("from MyEntity where id=1") .list(); @SuppressWarnings("unchecked") List<MyEntity> resultCasted = (List<MyEntity>) result; return resultCasted; } Also EntityManger looks cleaner and is also easier to test because EntityManager can be easily mocked. 5. What is hibernate configuration file? Hibernate configuration file contains database specific configurations and used to initialize SessionFactory. We provide database credentials or JNDI resource information in the hibernate configuration xml file. Some other important parts of hibernate configuration file is Dialect information, so that hibernate knows the database type and mapping file or class details. 6. What are the annotations used JPA implementation? @Entity – This marks class as Entity @Table – This maps class to database table @Id – Marks the class variable as primary key column in table @Column – Marks it as a column in table , we can also configure name attribute defining its name in database table @GeneratedValue – Marking a field with the @GeneratedValue annotation specifies that a value will be automatically generated for that field. This is primarily intended for primary key fields .There are below types of strategies – GenerationType.AUTO – It is the default generation type and lets the persistence provider choose the generation strategy. @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.IDENTITY – The GenerationType.IDENTITY is the easiest to use but not the best one from a performance point of view. It relies on an auto-incremented database column and lets the database generate a new value with each insert operation. From a database point of view, this is very efficient because the auto-increment columns are highly optimized, and it doesn’t require any additional statements. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.SEQUENCE – The GenerationType.SEQUENCE is my preferred way to generate primary key values and uses a database sequence to generate unique values. If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) @Column(name = “id”, updatable = false, nullable = false) private Long id; You can change that by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation. The @SequenceGenerator annotation lets you define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence. GenerationType.TABLE – The GenerationType.TABLE gets only rarely used nowadays. It simulates a sequence by storing and updating its current value in a database table which requires the use of pessimistic locks which put all transactions into a sequential order. This slows down your application, and you should, therefore, prefer the GenerationType.SEQUENCE, if your database supports sequences, which most popular databases do If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.TABLE) @Column(name = “id”, updatable = false, nullable = false) private Long id; Summary: AUTO: Hibernate selects the generation strategy based on the used dialect,IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key,SEQUENCE: Hibernate requests the primary key value from a database sequence,TABLE: Hibernate uses a database table to simulate a sequence. package com.anup.springboot.pojo; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; /** @author anup */ @Entity @Table(name = “TODO”) public class Todo implements Serializable { @Id @Column(name = “ID”) @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = “TASK_NAME”) private String taskName; @Column(name = “TASK_DESC”) private String taskDesc; @Column(name = “STATUS”) private String status; public Todo() { super(); } public Todo(Long id, String taskName, String taskDesc, String status) { super(); this.id = id; this.taskName = taskName; this.taskDesc = taskDesc; this.status = status; } //Setters and Getters } 7. Why is it advisable to use single instance of SessionFactory across your application? There are some key points regarding one SessionFactory Object per application : – 1.Single Data Store : – It is single data store for your whole application. Although you can have multiple SessionFactory but each SessionFactory will have one different database associated with it.SessionFactory is a heavy weight object. 2.Thread Safe : – SessionFactory is thread safe so due to this feature many thread can access the SessionFactory. 3.Immutable : – Once the SessionFactory’s object is created you can not change or set the values of Session Facoty. Its internal state is set at the time of creation. 4.Singleton : – SessionFactory is built at the time of application startup and it follows the singleton design pattern. Because creation of a SessionFactory is an extremely expensive process which involves parsing hibernate configuration/mapping properties and creating database connection pool .Creating a database connection pool requires establishing database connections (i.e creating Connection objects) which has overhead due to the time taken to locate the DB server , establish a communication channel and exchange information to do authentication. So if you create a SessionFactory for every request , it implies that you are not using database connection pool to serve your request .You have to setup a new connection by the above overheaded process for every request instead of just getting the opened connection from the database connection pool. 8. What is Session Object in Hibernate and when its used? We can create the Session object using SessionFactory. We create the session by calling openSession() method on factory object. Session session = factory.openSession(); OR Session session = factory.getCurrentSession(); Using this session object we can perform save,update,delete,get operations on the entities. 9. What is the difference between openSession and getCurrentSession methods? Hibernate SessionFactory openSession() method always opens a new session. We should close this session object once we are done with all the database operations. Hibernate SessionFactory getCurrentSession() method returns the session bound to the context. But for this to work, we need to configure it in hibernate configuration file. Since this session object belongs to the hibernate context, we don’t need to close it. Once the session factory is closed, this session object gets closed. 10. What are the possible states of entity bean? Entity bean can have below possible state – Transient: When ever we create a new object of Entity bean then we can say that is in Transient state,At that time any modification in the object state does not effect on database.Persistent: When ever the Object of entity bean associated with session we can say that is in persistent state, if any change in the object state , then that modification effects in database.Detached :When ever the object is removed from session then it enters in to detached state.Any modification on detached state object , does not effect in database. /** * @author anup */ @Entity @Table(name = “TODO”) public class Todo implements Serializable { @Id @Column(name = “ID”) @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = “TASK_NAME”) private String taskName; @Column(name = “TASK_DESC”) private String taskDesc; @Column(name = “STATUS”) private String status; public Todo() { super(); } public Todo(Long id, String taskName, String taskDesc, String status) { super(); this.id = id; this.taskName = taskName; this.taskDesc = taskDesc; this.status = status; } //Setters and Getters } class StateTest { public static void main(String[]args) { SessionnFactory factory=new Configuration().configure(“hibewrnate.cfg.xml”).buildSessionFactpry(); Sessiion session1=factory.openSession(); Todo e1=new Todo(1l, “Wakeup”, “Wake up at 7AM”, “DONE”); //Entity bean in Transient sate. Transaction tx1=session1.beginTransaction(); session1.save(e1); //Entity bean in persistent state e1.setTaskName(“Running”); //Will effect in db tx1.commit(); session1.close(); //Now e1 in ditached state e1.setStream(“Webservices”); //Will not effect in db } } 11. Why do we need to have no-arg constructor entity bean? The implementation of the default no arg constructor, is not mandatory . Only case where you need to specify it is when you declare another parametrized constructor. In Hibernate, no-arg constructor is used to loading database entities via Reflection . 12. Can you make entity class as final? You can make an Hibernate Entity class final, but that’s not a good practice. Generally, persistence providers make proxies of objects using some library like CGLIB or javassist. These proxies are creating runtime subclasses of the entities. That’s why they should not be final. Since Hibernate uses proxy pattern for performance improvement, so in case of lazy association, by making an entity final, Hibernate will no longer be able to use proxy, because Java doesn’t allow extension of final class, thus limiting your performance improvement options. 13. What is the difference between get() and load() and when to use what ? If no row with the given identifier value exists in the database, get() returns null. The load() method throws an ObjectNotFoundException. It’s your choice what error-handling you prefer. More important, the load() method may return a proxy, a placeholder, without hitting the database. The get() method on the other hand never returns a proxy, it always hits the database. Use get() when you want to load an objectUse load() when you need to obtain a reference to the object without issuing extra SQL queries, for example, to create a relationship with another object. public void savePost(long authorId, String text) { Post p = new Post(); p.setText(text); // No SELECT query here. // Existence of Author is ensured by foreign key constraint on Post. p.setAuthor(s.load(Author.class, authorId)); s.save(p); } 14. What is the first level cache in hibernate? Hibernate by default provides first level cache. It caches the database objects i.e. entities to reduce number of queries made to database in a single transaction. It is associated with Session object .As we create session object on demand from session factory and it is lost, once the session is closed. So first level cache is available till the time that session object is alive. It is available to session object only and is not accessible to any other session object in any other part of application. Case 1: Below example shows the role of first level cache while retrieving Department object twice – //Open the hibernate session Session session = HibernateUtil.getSessionFactory().openSession(); session.beginTransaction(); //fetch the department entity from database first time Department department = (Department) session.load(DepartmentEntity.class, new Integer(1)); System.out.println(department.getName()); //fetch the department entity again department = (Department) session.load(Department.class, new Integer(1)); System.out.println(department.getName()); session.getTransaction().commit(); HibernateUtil.shutdown(); Output: Hibernate: select department0_.ID as ID0_0_, department0_.NAME as NAME0_0_ from DEPARTMENT department0_ where department0_.ID=? COMPUTER COMPUTER Its quiet clear from the logs that when we get the object second time , its doesn’t hit the database. Object is cached on the first load itself. Case 2: Below example shows the role of first level cache while retrieving Department object from multiple sessions – //Open the hibernate session Session session = HibernateUtil.getSessionFactory().openSession(); session.beginTransaction(); Session sessionDummy = HibernateUtil.getSessionFactory().openSession(); sessionDummy.beginTransaction(); //fetch the department entity from database first time Department department = (Department) session.load(Department.class, new Integer(1)); System.out.println(department.getName()); //fetch the department entity again department = (Department) session.load(Department.class, new Integer(1)); System.out.println(department.getName()); //fetch the department entity again department = (Department) sessionDummy.load(Department.class, new Integer(1)); System.out.println(department.getName()); session.getTransaction().commit(); sessionDummy.getTransaction().commit(); HibernateUtil.shutdown(); Output: Hibernate: select department0_.ID as ID0_0_, department0_.NAME as NAME0_0_ from DEPARTMENT department0_ where department0_.ID=? COMPUTER COMPUTER Hibernate: select department0_.ID as ID0_0_, department0_.NAME as NAME0_0_ from DEPARTMENT department0_ where department0_.ID=? COMPUTER From the logs its quiet clear that when we load the object second time in single session, its doesn’t hit the database. But when we load the Object in different session, it hits the database again. Remove Objects from First Level Cache – Though we can not disable the first level cache in hibernate, but we can certainly remove some of objects from it when needed. This is done using two methods : evict()clear() Here evict() is used to remove a particular object from cache associated with session, and clear() method is used to remove all cached objects associated with session. 15. What is the second level cache in hibernate ? Second level cache works on SesionFactory level. So irrespective of multiple sessions , second level cache will cache the data across all sessions. This is apart from first level cache which is available to be used globally in session factory scope. Once session factory is closed, all cache associated with it die and cache manager also closed down. There are multiple implementations of second level cache provided by many vendors like – EH CacheOS CacheSwarm CacheJBoss Cache We need to add below dependency in maven – net.sf.ehcache ehcache 2.10.3 Also Entity class needs to be annotated with below annotations – package com.myjavablog; import javax.persistence.*; import org.hibernate.annotations.Cache; import org.hibernate.annotations.CacheConcurrencyStrategy; @Entity @Table(name=”TODO”) @Cacheable @Cache(usage=CacheConcurrencyStrategy.READ_ONLY) public class Todo implements Serializable { } Hibernate Configuration file hibernate.cfg.xml true update org.hibernate.dialect.Oracle9Dialect jdbc:oracle:thin:@localhost:1521:xe system jtp oracle.jdbc.driver.OracleDriver true org.hibernate.cache.ehcache.EhCacheRegionFactory Class to access the entity – //Open the hibernate session Session session1 = HibernateUtil.getSessionFactory().openSession(); session.beginTransaction(); Session session2 = HibernateUtil.getSessionFactory().openSession(); sessionDummy.beginTransaction(); //fetch the department entity from database first time Department department = (Department) session1.load(Department.class, new Integer(1)); System.out.println(department.getName()); //fetch the department entity again department = (Department) session2.load(Department.class, new Integer(1)); System.out.println(department.getName()); session1.getTransaction().commit(); session2.getTransaction().commit(); HibernateUtil.shutdown(); Output: Hibernate: select department0_.ID as ID0_0_, department0_.NAME as NAME0_0_ from DEPARTMENT department0_ where department0_.ID=? COMPUTER COMPUTER 16. What is the difference between save() and persist() methods ? Save() Returns generated Id after saving. Its Serializable return type.Saves the value to DB immediately and keeps track of the entity until the end of the session(I have tried to change the entity values outside of the transaction, it does not show any effect when session commits)save the changes to the db outside of the transaction.Assigns the generated id to the entity you are persistingSession.save() for a detached object will create a new row in the table. Persist() Does not returns generated Id after saving. Its void return type.Saves the value to DB immediately and keeps track of the entity until the end of the session.(I have tried to change the entity values outside of the transaction, it does not show any effect when session commits)Does not save the changes to the db outside of the transaction.Assigns the generated id to the entity you are persistingsession.persist() for a detached object will throw PersistentObjectException as it is not allowed. 17. What is the relationship and how to implement it? Two entities can have relationship between them . In relational database, two tables are related to by foreign key .This can be implemented in hibernate through below annotations. One To One MappingMany To One MappingOne To Many Mapping 18.What is cascading and what are different types of cascading? Two entities are related to each other via a foreign key relationship. When we have relationship between entities, then we need to define how the different operations will affect the other entity. In hibernate we use CASCADE operations to handle this. @Entity @Table(name = “STUDENT”) public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @Column private int mobile; @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = “DEPT_ID”) private Department department; Here Many students can be a part of single department . DEPT_ID is foreign key in Student table is associated to ID in Department table. Commonly used cascading types as defined in CascadeType enum are: None: No Cascading, it’s not a type but when we don’t define any cascading then no operations in parent affects the child.ALL: Cascades save, delete, update, evict, lock, replicate, merge, persist. Basically all operations.SAVE_UPDATE: Cascades save and update, available only in hibernate.DELETE: Corresponds to the Hibernate native DELETE action, only in hibernate.DETATCH, MERGE, PERSIST, REFRESH and REMOVE – for similar operationsLOCK: Corresponds to the Hibernate native LOCK action.REPLICATE: Corresponds to the Hibernate native REPLICATE action. 19. How to log the queries generated by hibernate on console? When we call methods like save,update,delete,get on entities in session then queries gets generated on backend by hibernate. We can see these queries on console by just adding below line to hibernate configuration file – true 20. What is Native SQL query in hibernate? You can write your own queries and execute them against the database. For Hibernate Native SQL Query, we use Session.createSQLQuery(String query) to create the SQLQuery object and execute it. Native SQL Query comes handy when we want to execute database specific queries that are not supported by Hibernate API such as query hints or the CONNECT keyword in Oracle Database. 21. What is Named Native SQL query in hibernate? Hibernate provides Named Query that we can define at a central location and use them anywhere in the code. We can create named queries for both HQL and Native SQL. Hibernate Named Queries can be defined in Hibernate mapping files or through the use of JPA annotations @NamedQuery and @NamedNativeQuery.... Read more...Java Interview QuestionsMarch 17, 2019InterviewIn this series of tutorials , i will share the most frequently asked questions in java interviews.... Read more...Many To One(Uni-directional) Relational Mapping with Spring Boot + Spring Data JPA + H2 DatabaseJanuary 6, 2019Spring Data JPAIn this tutorial , we will see Many To One mapping of two entities using Spring Boot and Spring Data JPA using H2 database. GitHub Link – Download Tools: Spring BootSpring Data JPAH2 DatabaseIntelliJ IDEAMaven We have two entities Student and Department. Many students are part of one Department (Many To One). This is called Many To One mapping between two entities. For each of this entity, table will be created in database. So there will be two tables created in database. create table address (id bigint generated by default as identity, name varchar(255), primary key (id)); create table student (id bigint generated by default as identity, mobile integer, name varchar(255), address_id bigint, primary key (id)); alter table student add constraint FKcaf6ht0hfw93lwc13ny0sdmvo foreign key (address_id) references address(id); Each table has primary key as ID . Two tables has Many To One relationship between them as each department has many students in them. STUDENT table has foreign key as DEPT_ID in it. So STUDENT is a child table and DEPARTMENT table is parent table in this relationship. FOREIGN KEY constraint adds below restrictions – We can’t add records in child table if there is no entry in parent table. Ex. You can’t add department ID reference in STUDENT table if department ID is not present in DEPARTMENT table.You can’t delete the records from parent table unless corresponding references are deleted from child table . Ex. You can’t delete the entryDEPARTMENT table unless corresponding students from STUDENT table are deleted . You can apply ON_DELETE_CASCADE with foreign key constraint if you want to delete students from STUDENT table automatically when department is deleted. If you want to insert a student into STUDENT table then corresponding department should already be present in DEPARTMENT table.When any department is updated in DEPARTMENT table then child table will also see the updated reference from parent table Now we will see how can we form this relationship using Spring data JPA entities. Step 1: Define all the dependencies required for this project 4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.1.RELEASE com.myjavablog springboot-jpa-one-to-many-demo 0.0.1-SNAPSHOT springboot-jpa-one-to-many-demo Demo project for Spring Boot <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <exclusions> <exclusion> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jdbc</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <!--<scope>runtime</scope>--> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!-- https://mvnrepository.com/artifact/colt/colt --> <dependency> <groupId>colt</groupId> <artifactId>colt</artifactId> <version>1.2.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> spring-boot-starter-data-jpa – This jar is used to connect to database .It also has a support to provide different JPA implementations to interact with the database like Hibernate, JPA Repository, CRUD Repository etc. h2 – Its used to create H2 database when the spring boot application boots up. Spring boot will read the database configuration from application.properties file and creates a DataSource out of it. Step 2: Define the Model/Entity classes Student.java package com.myjavablog.model; import org.springframework.stereotype.Repository; import javax.annotation.Generated; import javax.persistence.*; import java.util.Optional; @Entity @Table(name = “STUDENT”) public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @Column private int mobile; @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = “DEPT_ID”) private Department department; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMobile() { return mobile; } public void setMobile(int mobile) { this.mobile = mobile; } public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } } Department.java package com.myjavablog.model; import javax.persistence.*; import java.util.List; @Entity @Table(name = “DEPARTMENT”) public class Department { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } Below are the Annotations used while creating the entity classes – Spring Data JPA Annotations – @Entity – This annotation marks the class [email protected] – This annotation creates table in [email protected] – It creates primary key in [email protected] – It defines primary key generation strategy like AUTO,IDENTITY,SEQUENCE [email protected] – It defines column property for [email protected] – This annotation creates Many to One relationship between Student and Department entities. The cascade property (CascadeType.ALL) defines what should happen with child table records when something happens with parent table records. On DELETE, UPDATE , INSERT operations in parent table child table should also be affected. Only @ManyToOne annotation is enough to form one-to-many relationaship. This annotation is generally used in child entity to form Unidirectional relational [email protected] – You can define column which creates foreign key in a table. In our example, DEPT_ID is a foreign key in STUDENT table which references to ID in DEPARTMENT table. Step 3: Create the JPA repositories to query STUDENT and DEPARTMENT tables StudentRepository and AddressRepository implemets JpaRepository which has methods to perform all CRUD operations. It has methods like save(), find(), delete(),exists(),count() to perform database operations. package com.myjavablog.dao; import com.myjavablog.model.Student; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface StudentRepository extends JpaRepository { public Student findByName(String name); } package com.myjavablog.dao; import com.myjavablog.model.Address; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface AddressRepository extends JpaRepository{ } Step 4: Create the class BeanConfig to configure the bean for H2 database This class creates a bean ServletRegistrationBean and autowires it to spring container. This bean actually required to access H2 database from console through browser. package com.myjavablog; import org.h2.server.web.WebServlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class BeanConfig { @Bean ServletRegistrationBean h2servletRegistration() { ServletRegistrationBean registrationBean = new ServletRegistrationBean(new WebServlet()); registrationBean.addUrlMappings(“/console/*”); return registrationBean; } } Step 5: Last but not the least, You need to define application properties. #DATASOURCE (DataSourceAutoConfiguration & #DataSourceProperties) spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE spring.datasource.username=sa spring.datasource.password= #Hibernate #The SQL dialect makes Hibernate generate better SQL for the chosen #database spring.jpa.properties.hibernate.dialect =org.hibernate.dialect.H2Dialect spring.datasource.driverClassName=org.h2.Driver #Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto = update logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type=TRACE server.port=8082 server.error.whitelabel.enabled=false Step 6: Create the spring boot main file package com.myjavablog; import com.myjavablog.dao.DepartmentRepository; import com.myjavablog.dao.StudentRepository; import com.myjavablog.model.Department; import com.myjavablog.model.Student; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import java.util.Arrays; @SpringBootApplication public class SpringbootJpaOneToManyDemoApplication implements CommandLineRunner { @Autowired private DepartmentRepository departmentRepository; @Autowired private StudentRepository studentRepository; public static void main(String[] args) { SpringApplication.run(SpringbootJpaOneToManyDemoApplication.class, args); } @Override public void run(String… args) throws Exception { //Unidirectional Mapping Department department = new Department(); department.setName(“COMPUTER”); departmentRepository.save(department); Student student = new Student(); student.setDepartment(departmentRepository.findDepartmentByName(“COMPUTER”)); student.setName(“Anup”); student.setMobile(989911); Student student1 = new Student(); student1.setDepartment(departmentRepository.findDepartmentByName(“IT”)); student1.setName(“John”); student1.setMobile(89774); studentRepository.saveAll(Arrays.asList(student,student1)); } } Step 7: Now run the application Run the application as a java application or as spring boot application spring-boot:run Once you run the application records will be inserted to tables as below – Step 8: This application also has REST endpoints to expose the services as below – Save department – Add students under created department – We can check database entries to cross verify –... Read more...One To Many (Bi-directional) Relational Mapping with Spring Boot + Spring Data JPA + H2 DatabaseJanuary 1, 2019Spring Data JPAIn this tutorial , we will see One To Many mapping of two entities using Spring Boot and Spring Data JPA using H2 database. GitHub Link – Download Tools: Spring BootSpring Data JPAH2 DatabaseIntelliJ IDEAMaven We have two entities Student and Department. Many students are part of one Department (Many To One). And vice a versa i.e. each Department has many students in it (One To Many) . This is called One To Many and Many To One mapping between two entities. For each of this entity, table will be created in database. So there will be two tables created in database. create table address (id bigint generated by default as identity, name varchar(255), primary key (id)); create table student (id bigint generated by default as identity, mobile integer, name varchar(255), address_id bigint, primary key (id)); alter table student add constraint FKcaf6ht0hfw93lwc13ny0sdmvo foreign key (address_id) references address(id); Each table has primary key as ID . Two tables has One To Many relationship between them. All student has department associated with them and each department has many students in them. STUDENT table has foreign key as DEPT_ID in it. So STUDENT is a child table and DEPARTMENT table is parent table in this relationship. FOREIGN KEY constraint adds below restrictions – We can’t add records in child table if there is no entry in parent table. Ex. You can’t add department ID reference in STUDENT table if department ID is not present in DEPARTMENT table.You can’t delete the records from parent table unless corresponding references are deleted from child table . Ex. You can’t delete the entryDEPARTMENT table unless corresponding students from STUDENT table are deleted . You can apply ON_DELETE_CASCADE with foreign key constraint if you want to delete students from STUDENT table automatically when department is deleted. If you want to insert a student into STUDENT table then corresponding department should already be present in DEPARTMENT table.When any department is updated in DEPARTMENT table then child table will also see the updated reference from parent table Now we will see how can we form this relationship using Spring data JPA entities. Step 1: Define all the dependencies required for this project 4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.1.RELEASE com.myjavablog springboot-jpa-one-to-many-demo 0.0.1-SNAPSHOT springboot-jpa-one-to-many-demo Demo project for Spring Boot <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <exclusions> <exclusion> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jdbc</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <!--<scope>runtime</scope>--> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!-- https://mvnrepository.com/artifact/colt/colt --> <dependency> <groupId>colt</groupId> <artifactId>colt</artifactId> <version>1.2.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> spring-boot-starter-data-jpa – This jar is used to connect to database .It also has a support to provide different JPA implementations to interact with the database like Hibernate, JPA Repository, CRUD Repository etc. h2 – Its used to create H2 database when the spring boot application boots up. Spring boot will read the database configuration from application.properties file and creates a DataSource out of it. Step 2: Define the Model/Entity classes Student.java package com.myjavablog.model; import org.springframework.stereotype.Repository; import javax.annotation.Generated; import javax.persistence.*; import java.util.Optional; @Entity @Table(name = “STUDENT”) public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @Column private int mobile; @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = “DEPT_ID”) private Department department; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMobile() { return mobile; } public void setMobile(int mobile) { this.mobile = mobile; } public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } } Department.java package com.myjavablog.model; import javax.persistence.*; import java.util.List; @Entity @Table(name = “DEPARTMENT”) public class Department { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @OneToMany(mappedBy = “department”) private List studentList; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public List getStudentList() { return studentList; } public void setStudentList(List studentList) { this.studentList = studentList; } } Below are the Annotations used while creating the entity classes – Spring Data JPA Annotations – @Entity – This annotation marks the class [email protected] – This annotation creates table in [email protected] – It creates primary key in [email protected] – It defines primary key generation strategy like AUTO,IDENTITY,SEQUENCE [email protected] – It defines column property for [email protected] – This annotation is used in the owning entity/Parent entity. This annotation is required in only if you want Bi-directional relational [email protected] – This annotation creates Many to one relationship between Student and Department entities. The cascade property (CascadeType.ALL) defines what should happen with child table records when something happens with parent table records. On DELETE, UPDATE , INSERT operations in parent table child table should also be affected. Both @OneToMany and @ManyToOne annotations are required to form Bi-directional relational mapping. @JoinColumn – You can define column which creates foreign key in a table. In our example, DEPT_ID is a foreign key in STUDENT table which references to ID in DEPARTMENT table. Step 3: Create the JPA repositories to query STUDENT and DEPARTMENT tables StudentRepository and AddressRepository implemets JpaRepository which has methods to perform all CRUD operations. It has methods like save(), find(), delete(),exists(),count() to perform database operations. package com.myjavablog.dao; import com.myjavablog.model.Student; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface StudentRepository extends JpaRepository { public Student findByName(String name); } package com.myjavablog.dao; import com.myjavablog.model.Address; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface AddressRepository extends JpaRepository{ } Step 4: Create the class BeanConfig to configure the bean for H2 database This class creates a bean ServletRegistrationBean and autowires it to spring container. This bean actually required to access H2 database from console through browser. package com.myjavablog; import org.h2.server.web.WebServlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class BeanConfig { @Bean ServletRegistrationBean h2servletRegistration() { ServletRegistrationBean registrationBean = new ServletRegistrationBean(new WebServlet()); registrationBean.addUrlMappings(“/console/*”); return registrationBean; } } Step 5: Last but not the least, You need to define application properties. #DATASOURCE (DataSourceAutoConfiguration & #DataSourceProperties) spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE spring.datasource.username=sa spring.datasource.password= #Hibernate #The SQL dialect makes Hibernate generate better SQL for the chosen #database spring.jpa.properties.hibernate.dialect =org.hibernate.dialect.H2Dialect spring.datasource.driverClassName=org.h2.Driver #Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto = update logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type=TRACE server.port=8082 server.error.whitelabel.enabled=false Step 6: Create the spring boot main file package com.myjavablog; import com.myjavablog.dao.DepartmentRepository; import com.myjavablog.dao.StudentRepository; import com.myjavablog.model.Department; import com.myjavablog.model.Student; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import java.util.Arrays; @SpringBootApplication public class SpringbootJpaOneToManyDemoApplication implements CommandLineRunner { @Autowired private DepartmentRepository departmentRepository; @Autowired private StudentRepository studentRepository; public static void main(String[] args) { SpringApplication.run(SpringbootJpaOneToManyDemoApplication.class, args); } @Override public void run(String… args) throws Exception { //Bi-directional mapping Department department1 = new Department(); department1.setName(“IT”); //Students list Student student = new Student(); student.setName(“Danny”); student.setMobile(33333); student.setDepartment(department1); Student student1 = new Student(); student1.setName(“Mark”); student1.setMobile(11111); student1.setDepartment(department1); //department1.setStudentList(Arrays.asList(student,student1)); department1.getStudentList().add(student); department1.getStudentList().add(student1); departmentRepository.save(department1); //Get the list of students from department Department department = departmentRepository.findDepartmentById(1l); for(Student s : department.getStudentList()) System.out.println(s); } } Step 7: Now run the application Run the application as a java application or as spring boot application spring-boot:run Once you run the application records will be inserted to tables as below – Step 8: This application also has REST endpoints to expose the services as below – Save department – Add students under created department – We can check database entries to cross verify – Bi-directional Relational Mapping – To create the bi-directional mapping between entities, we need to below changes in entities – The idea with bidirectional one-to-many association is to allow you to keep a collection of child entities in the parent and enable you to persist and retrieve the child entities via the parent entity. In our example, Department entity has list of students in it. So we can access all students from particular department. //Bi-directional mapping Department department = new Department(); department.setName(“IT”); //Students list Student student = new Student(); student.setName(“Danny”); student.setMobile(33333); Student student1 = new Student(); student1.setName(“Mark”); student1.setMobile(11111); department.setStudentList(Arrays.asList(student,student1)); departmentRepository.save(department); Hibernate automatically issues insert statements and saves the Students added to the Department. Similarly, you could fetch Students via the Department entity like so – //Retrieve department Department department1 = departmentRepository.findDepartmentById(1l); // Retrieve students from Department System.out.println(department1.getStudentList()); When you write department1.getStudentList(), hibernate loads all the comments from the database if they are not already loaded. Problems with bidirectional one-to-many mapping A bidirectional mapping tightly couples the many-side of the relationship to the one-side.In our example, If you load students via the Department entity, you won’t be able to limit the number of students loaded. That essentially means that you won’t be able to paginate.If you load students via the Department entity, you won’t be able to sort them based on different properties. You can define a default sorting order using @OrderColumn annotation but that will have performance implications.You’ll have to face multiple times LazyInitializationException. When can you use a bidirectional one-to-many mapping A bidirectional one-to-many mapping might be a good idea if the number of child entities is limited. Moreover, A bidirectional mapping tightly couples the many-side of the relationship to the one-side. Many times, this tight coupling is desired. Example: When you have to design an application for multiple choices questions then you should have two entities like Question and Choice. When you fetch the Question then Choices will also be fetched with that question. So Question and Choice has tight coupling between them. So to decide between bidirectional and unidirectional mappings, you should think whether the entities have a tight coupling or not... Read more...One To One Relationship with Spring Boot + Spring Data JPA + H2 DatabaseJanuary 1, 2019Spring Data JPAIn this tutorial , we will see One To One mapping of two entities using Spring Boot and Spring Data JPA using H2 database. GitHub Link – Download Tools: Spring BootSpring Data JPAH2 DatabaseIntelliJ IDEAMavenLombok We have two entities Student and Address. Each student has single address attached to him. And vice a versa i.e. each address is attached to student . This is called One To One mapping between two entities. For each of this entity, table will be created in database. So there will be two tables created in database. create table address (id bigint generated by default as identity, name varchar(255), primary key (id)); create table student (id bigint generated by default as identity, mobile integer, name varchar(255), address_id bigint, primary key (id)); alter table student add constraint FKcaf6ht0hfw93lwc13ny0sdmvo foreign key (address_id) references address(id); Each table has primary key as ID . Two tables has One To One relationship between them. Each student has address associated with him and each address has one student. STUDENT table has foreign key as ADDRESS_ID in it. So STUDENT is a child table and ADDRESS table is parent table in this relationship. Now we will see how can we form this relationship using Spring data JPA entities. Step 1: Define all the dependencies required for this project 4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.1.RELEASE com.myjavablog spring-boot-data-jpa-one-to-one 0.0.1-SNAPSHOT spring-boot-data-jpa-one-to-one Demo project for Spring Boot <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <!--<scope>runtime</scope>--> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!-- For JSP compilation --> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> Lombok – We will be using lombok third party library to reduce boilerplate code for model/data objects, e.g., it can generate getters and setters for those object automatically by using Lombok annotations. The easiest way is to use the @Data annotation.spring-boot-starter-data-jpa – This jar is used to connect to database .It also has a support to provide different JPA implementations to interact with the database like Hibernate, JPA Repository, CRUD Repository etc.h2 – Its used to create H2 database when the spring boot application boots up. Spring boot will read the database configuration from application.properties file and creates a DataSource out of it. Step 2: Define the Model/Entity Student.java package com.myjavablog.model; import org.springframework.stereotype.Repository; import javax.annotation.Generated; import javax.persistence.*; import java.util.Optional; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import javax.persistence.*; @Data @Builder @AllArgsConstructor @NoArgsConstructor @Entity @Table(name = "STUDENT") public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @Column private int mobile; @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name = "ADDRESS_ID") private Address address; public Student(String name, int mobile, Address address) { this.name=name; this.mobile=mobile; this.address=address; } @Override public String toString() { return "Student{" + "id=" + id + ", name='" + name + '\'' + ", mobile=" + mobile + '}'; } } Address.java package com.myjavablog.model; import javax.persistence.*; import java.util.List; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import javax.persistence.*; @Data @Builder @AllArgsConstructor @NoArgsConstructor @Entity @Table(name = "ADDRESS") public class Address { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @OneToOne(mappedBy = "address") private Student student; public Address(String name) { this.name =name; } @Override public String toString() { return "Address{" + "id=" + id + ", name='" + name + '\'' + '}'; } } Below are the Annotations used while creating the entity classes - Lombok annotations - @Data – Define this class as Model [email protected] – To build the model object at runtime ex. Create mock object for unit [email protected] – Create constructor with all [email protected] – Default constructor Spring Data JPA Annotations - @Entity - This annotation marks the class [email protected] - This annotation creates table in [email protected] - It creates primary key in [email protected] - It defines primary key generation strategy like AUTO,IDENTITY,SEQUENCE [email protected] - It defines column property for [email protected] - This annotation creates one to one relationship between Student and Address entities. The cascade property (CascadeType.ALL) defines what should happen with child table records when something happens with parent table records. On DELETE, UPDATE , INSERT operations in parent table child table should also be affected. @JoinColumn - You can define column which creates foreign key in a table. In our example, ADDRESS_ID is a foreign key in STUDENT table which references to ID in ADDRESS table. Step 3: Create the JPA repositories to query STUDENT and ADDRESS tables StudentRepository and AddressRepository implemets JpaRepository which has methods to perform all CRUD operations. It has methods like save(), find(), delete(),exists(),count() to perform database operations. package com.myjavablog.dao; import com.myjavablog.model.Student; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface StudentRepository extends JpaRepository { public Student findByName(String name); } package com.myjavablog.dao; import com.myjavablog.model.Address; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface AddressRepository extends JpaRepository{ } Step 4: Create the class BeanConfig to configure the bean for H2 database This class creates a bean ServletRegistrationBean and autowires it to spring container. This bean actually required to access H2 database from console through browser. package com.myjavablog; import org.h2.server.web.WebServlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class BeanConfig { @Bean ServletRegistrationBean h2servletRegistration() { ServletRegistrationBean registrationBean = new ServletRegistrationBean(new WebServlet()); registrationBean.addUrlMappings("/console/*"); return registrationBean; } } Step 5: Lat but not the least, You need to define application properties. DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties) spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE spring.datasource.username=sa spring.datasource.password= Hibernate The SQL dialect makes Hibernate generate better SQL for the chosen database spring.jpa.properties.hibernate.dialect =org.hibernate.dialect.H2Dialect spring.datasource.driverClassName=org.h2.Driver Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto = update logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type=TRACE server.port=8082 server.error.whitelabel.enabled=false Step 6: Now run the application Once you run the application records will be inserted to tables as below -... Read more...Spring Boot + Spring Data JPA + H2 DatabaseDecember 30, 2018Spring Data JPAIn this example , we will create a simple Spring boot application which will interact with the H2 database using Spring JPA library. H2 database is an in memory database .For this tutorial , we will use H2 database for this demo so that we don’t need to perform heavy installation for other database like Oracle,MySQL. GitHub Link – Download Tools – Spring BootSpring JPAH2 DatabaseIntelliJ IDEA editorMavenLombok Step 1: Create the simple spring boot web application in IntelliJ IDEA editor Project Setup Guide Our final Project structure will look like below– Step 2: Now define all maven dependencies required in this project 4.0.0 org.springframework.boot spring-boot-starter-parent 1.5.1.RELEASE com.myjavablog springhibernatewithh2database 0.0.1-SNAPSHOT springhibernatewithh2database Demo project for Spring Boot <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <exclusions> <exclusion> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jdbc</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <!--<scope>runtime</scope>--> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> Lombok – We will be using lombok third party library to reduce boilerplate code for model/data objects, e.g., it can generate getters and setters for those object automatically by using Lombok annotations. The easiest way is to use the @Data annotation. spring-boot-starter-data-jpa – This jar is used to connect to database .It also has a support to provide different JPA implementations to interact with the database like Hibernate, JPA Repository, CRUD Repository etc. h2 – Its used to create H2 database when the spring boot application boots up. Spring boot will read the database configuration from application.properties file and creates a DataSource out of it. Step 2: Create the Model class package com.myjavablog.pojo; import javax.persistence.*; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; @Data @Builder @AllArgsConstructor @NoArgsConstructor @Entity @Table public class UserDetails { @Id @Column @GeneratedValue(strategy = GenerationType.IDENTITY) private int id; @Column private String firstName; @Column private String lastName; @Column private String email; @Column private String password; } We have used Lombok library in Model class . You can see below annotation which are coming from Lambok jar – @Data – Define this class as Model class @Builder – To build the model object at runtime ex. Create mock object for unit testing @AllArgsConstructor – Create constructor with all arguments @NoArgsConstructor – Default constructor So Lombok takes care of everything for you right from creating setters/ getters, Constructor , Build runtime objects and avoids boilerplate code . Step 3: Configuration for the H2 database bean package com.myjavablog.config; import org.h2.server.web.WebServlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class BeanConfig { @Bean ServletRegistrationBean h2servletRegistration() { ServletRegistrationBean registrationBean = new ServletRegistrationBean(new WebServlet()); registrationBean.addUrlMappings("/console/*"); return registrationBean; } } We can also configure the security for the application. package com.myjavablog.config; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity httpSecurity) throws Exception { httpSecurity.csrf().disable().authorizeRequests().antMatchers("/").permitAll().and().authorizeRequests() .antMatchers("/console/**").permitAll() .antMatchers("/list/**").permitAll(); httpSecurity.headers().frameOptions().disable(); } } Step 4: Service layer package com.myjavablog.service; import com.myjavablog.pojo.UserDetails; import java.util.List; public interface UserService { public List getUserDetails(); } package com.myjavablog.service; import com.myjavablog.dao.UserDao; import com.myjavablog.pojo.UserDetails; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service public class UserServiceImpl implements UserService { @Autowired UserDao userDao; @Override public List getUserDetails() { return userDao.getUserDetails(); } } Step 5: DAO layer package com.myjavablog.dao; import com.myjavablog.pojo.UserDetails; import java.util.List; public interface UserDao { public List getUserDetails(); } package com.myjavablog.dao; import com.myjavablog.pojo.UserDetails; import javax.persistence.*; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; import org.hibernate.Criteria; import org.hibernate.Session; import org.springframework.stereotype.Repository; import java.util.List; @Repository public class UserDaoImpl implements UserDao { @PersistenceContext private EntityManager entityManager ; @Override public List getUserDetails() { Criteria criteria; criteria = entityManager.unwrap(Session.class).createCriteria(UserDetails.class); return criteria.list(); } } Step 7: Create Controller class package com.myjavablog.controller; import com.myjavablog.pojo.UserDetails; import com.myjavablog.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import java.util.List; @Controller public class UserController { @Autowired private UserService userService; @RequestMapping(value = "/list", method = RequestMethod.GET) public ResponseEntity userDetails() { List userDetails = userService.getUserDetails(); return new ResponseEntity(userDetails, HttpStatus.OK); } } Step 8 : Create a properties file to configure Spring boot application and database spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE spring.datasource.username=sa spring.datasource.password= spring.datasource.driverClassName=org.h2.Driver spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect server.port=8081 server.error.whitelabel.enabled=false Step 9: Now application is ready . Run the application and Java application and access URL http://localhost:8081/console to access H2 database. Once you connect to it you can insert records to table. Now you can access the application to get the list of users.... Read more...Spring Boot + Spring Security + H2 DatabaseDecember 29, 2018Spring SecurityIn this tutorial , we will see how to secure your web application by authenticating and authorizing users against database. User and role information is stored in database . GitHub Link:Code for this example can be found on below gitHub link- Download Tools : Spring Boot 2.1.1.RELEASESpring MVCSpring Security MavenIntelliJ IDEALombok Step 1: Create a simple spring boot application in Intellij IDEA editor as shown in below link – Project Setup Our final Project structure will look like – Step 2:Define all dependencies required in pom file as below – 4.0.0 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.myjavablog</groupId> <artifactId>spring-boot-database-security</artifactId> <version>0.0.1-SNAPSHOT</version> <name>spring-boot-database-security</name> <description>Demo project for Spring Boot</description> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <exclusions> <exclusion> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-jdbc</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <!--<scope>runtime</scope>--> </dependency> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> In addition to spring-boot-starter-security dependency ,we will be using lombok third party library to reduce boilerplate code for model/data objects, e.g., it can generate getters and setters for those object automatically by using Lombok annotations. The easiest way is to use the @Data annotation. Step3: Now create a configuration for creating beans for BCryptPasswordEncoder and H2 database . Also we need to configure security mechanism through database using configuration file – package com.myjavablog.config; import org.h2.server.web.WebServlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class BeanConfiguration implements WebMvcConfigurer { @Bean public BCryptPasswordEncoder passwordEncoder() { BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder(); return bCryptPasswordEncoder; } @Bean ServletRegistrationBean h2servletRegistration() { ServletRegistrationBean registrationBean = new ServletRegistrationBean(new WebServlet()); registrationBean.addUrlMappings("/console/*"); return registrationBean; } } package com.myjavablog.config; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.builders.WebSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import javax.sql.DataSource; @Configuration @EnableWebSecurity public class SecurityConfiguration extends WebSecurityConfigurerAdapter { @Autowired private BCryptPasswordEncoder bCryptPasswordEncoder; @Autowired private DataSource dataSource; @Value("${spring.queries.users-query}") private String usersQuery; @Value("${spring.queries.roles-query}") private String rolesQuery; @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth. jdbcAuthentication() .usersByUsernameQuery(usersQuery) .authoritiesByUsernameQuery(rolesQuery) .dataSource(dataSource) .passwordEncoder(bCryptPasswordEncoder); } @Override protected void configure(HttpSecurity http) throws Exception { http. authorizeRequests() .antMatchers("/").permitAll() .antMatchers("/login").permitAll() .antMatchers("/registration").permitAll() .antMatchers("/admin/**").hasAuthority("ADMIN").anyRequest() .authenticated().and().csrf().disable().formLogin() .loginPage("/login").failureUrl("/login?error=true") .defaultSuccessUrl("/admin/adminHome") .usernameParameter("email") .passwordParameter("password") .and().logout() .logoutRequestMatcher(new AntPathRequestMatcher("/logout")) .logoutSuccessUrl("/").and().exceptionHandling() .accessDeniedPage("/access-denied") ; } @Override public void configure(WebSecurity web) throws Exception { web.ignoring() .antMatchers("/resources/**", "/static/**", "/css/**", "/js/**", "/images/**", "/console/**"); } } Step 4: Create a model classes for User and Role As we are using lombok libarary , we dont need to create setter and getter in model class . Also it helps in building mock objects at runtime for unit testing. package com.myjavablog.model; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import org.hibernate.validator.constraints.Length; import javax.persistence.*; import javax.validation.constraints.Email; import javax.validation.constraints.NotEmpty; import java.util.Set; @Data @Builder @AllArgsConstructor @NoArgsConstructor @Entity @Table(name = “USER”) public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "USER_ID") private int id; @Column(name = "EMAIL") @Email(message = "*Please provide a valid Email") @NotEmpty(message = "*Please provide an email") private String email; @Column(name = "PASSWORD") @Length(min = 5, message = "*Your password must have at least 5 characters") @NotEmpty(message = "*Please provide your password") private String password; @Column(name = "NAME") @NotEmpty(message = "*Please provide your name") private String name; @Column(name = "LAST_NAME") @NotEmpty(message = "*Please provide your last name") private String lastName; @Column(name = "ACTIVE") private int active; @ManyToMany(cascade = CascadeType.ALL) @JoinTable(name = "USER_ROLE", joinColumns = @JoinColumn(name = "USER_ID"), inverseJoinColumns = @JoinColumn(name = "ROLE_ID")) private Set<Role> roles; } package com.myjavablog.model; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import javax.persistence.*; @Data @Builder @AllArgsConstructor @NoArgsConstructor @Entity @Table(name = “ROLE”) public class Role { @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = “ROLE_ID”) private int id; @Column(name = “ROLE”) private String role; } Step 5: Create Service layer – package com.myjavablog.service; import com.myjavablog.model.User; import org.springframework.stereotype.Service; public interface UserService { public User findUserByEmail(String email) ; public User saveUser(User user); } package com.myjavablog.service; import com.myjavablog.model.Role; import com.myjavablog.model.User; import com.myjavablog.repository.RoleRepository; import com.myjavablog.repository.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.stereotype.Service; import java.util.Arrays; import java.util.HashSet; @Service public class UserServiceImpl implements UserService { private UserRepository userRepository; private RoleRepository roleRepository; private BCryptPasswordEncoder bCryptPasswordEncoder; @Autowired public UserServiceImpl(UserRepository userRepository, RoleRepository roleRepository, BCryptPasswordEncoder bCryptPasswordEncoder) { this.userRepository = userRepository; this.roleRepository = roleRepository; this.bCryptPasswordEncoder = bCryptPasswordEncoder; } @Override public User findUserByEmail(String email) { return userRepository.findByEmail(email); } @Override public User saveUser(User user) { user.setPassword(bCryptPasswordEncoder.encode(user.getPassword())); user.setActive(1); Role userRole = roleRepository.findByRole("ADMIN"); user.setRoles(new HashSet<Role>(Arrays.asList(userRole))); return userRepository.save(user); } } Step 6: Create JPA repositories for User and Role to interact with the databse – package com.myjavablog.repository; import com.myjavablog.model.Role; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface RoleRepository extends JpaRepository { public Role findByRole(String role); } package com.myjavablog.repository; import com.myjavablog.model.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface UserRepository extends JpaRepository { public User findByEmail(String email); } Step 7: Create a controller to save the user and navigate package com.myjavablog.controller; import com.myjavablog.model.User; import com.myjavablog.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.stereotype.Controller; import org.springframework.validation.BindingResult; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; import javax.validation.Valid; @Controller public class UserController { @Autowired private UserService userService; @RequestMapping(value={"/", "/login"}, method = RequestMethod.GET) public ModelAndView login(){ ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("login"); return modelAndView; } @RequestMapping(value="/registration", method = RequestMethod.GET) public ModelAndView registration(){ ModelAndView modelAndView = new ModelAndView(); User user = new User(); modelAndView.addObject("user", user); modelAndView.setViewName("registration"); return modelAndView; } @RequestMapping(value = "/registration", method = RequestMethod.POST) public ModelAndView createNewUser(@Valid User user, BindingResult bindingResult) { ModelAndView modelAndView = new ModelAndView(); User userExists = userService.findUserByEmail(user.getEmail()); if (userExists != null) { bindingResult .rejectValue("email", "error.user", "There is already a user registered with the email provided"); } if (bindingResult.hasErrors()) { modelAndView.setViewName("registration"); } else { userService.saveUser(user); modelAndView.addObject("successMessage", "User has been registered successfully"); modelAndView.addObject("user", new User()); modelAndView.setViewName("registration"); } return modelAndView; } @RequestMapping(value="/admin/adminHome", method = RequestMethod.GET) public ModelAndView home(){ ModelAndView modelAndView = new ModelAndView(); Authentication auth = SecurityContextHolder.getContext().getAuthentication(); User user = userService.findUserByEmail(auth.getName()); modelAndView.addObject("userName", "Welcome " + user.getName() + " " + user.getLastName() + " (" + user.getEmail() + ")"); modelAndView.addObject("adminMessage","This Page is available to Users with Admin Role"); modelAndView.setViewName("admin/adminHome"); return modelAndView; } @RequestMapping(value="/user/userHome", method = RequestMethod.GET) public ModelAndView user(){ ModelAndView modelAndView = new ModelAndView(); Authentication auth = SecurityContextHolder.getContext().getAuthentication(); User user = userService.findUserByEmail(auth.getName()); modelAndView.addObject("userName", "Welcome " + user.getName() + " " + user.getLastName() + " (" + user.getEmail() + ")"); modelAndView.addObject("userMessage","This Page is available to Users with User Role"); modelAndView.setViewName("user/userHome"); return modelAndView; } } Step 8: Create a UI layer using Thymleaf templates . Step 9: Run the application and go to H2 database console by navigating to http://localhost:8081/console Once the application is up and running , H2 database will be automatically started. You can navigate to http://localhost:8081/console to see the tables created as shown below- Also you need to insert few roles initially. INSERT INTO ROLE VALUES (1, “ADMIN”); INSERT INTO ROLE VALUES (2, “USER”); Step 10: Now go to application http://localhost:8081/ You can navigate to registration page by clicking on “Go to registration page ” at the top . Once you register , User details will be saved to USER table – Now when you login with registered user details then you can see the admin page . As registered user is ADMIN role, Admin page will be displayed.... Read more...Spring boot + Spring security default authenticationDecember 26, 2018Spring SecurityYou can secure your web applications using spring security. By using spring security with spring boot , you can minimize lot of configurations to be done for securing these applications. Spring boot will automatically bootstrap your spring security jar (spring-boot-starter-security) added in your maven dependency and enable default security for your applications. It will intercept all requests coming to application and asks user for authentication using spring security method used in our configuration. We can add security in different ways like inMemory, database, LDAP, OAUTH etc. In this post, i will show a default security provided by spring boot security. GitHub Link: Download Tools : Tomcat Embed 8Maven 3.3Java 8IntelliJ IDEA Spring boot 2.1.1.RELEASE Spring Security 5.1.2.RELEASE Step 1: Create a simple spring boot application in Intellij IDEA editor Create new project using Spring Initializr as shown below – Project Structure: Step 2: Define all required dependencies for application 4.0.0 <groupId>com.myjavablog</groupId> <artifactId>SpringBootSpringSecurityDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringBootSpringSecurityDemo</name> <description>Demo project for Spring Boot with spring security</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath /> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <!-- JSTL for JSP --> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!-- For JSP compilation --> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!-- https://mvnrepository.com/artifact/org.threeten/threetenbp --> <dependency> <groupId>org.threeten</groupId> <artifactId>threetenbp</artifactId> <version>0.7.2</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> Step 3: Create a HomeController.java package com.myjavablog.controller; import org.springframework.boot.web.servlet.error.ErrorController; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HomeController implements ErrorController { @GetMapping(“/”) public String homePage(){ return “Successfully logged in…”; } final String PATH = “/error”; @RequestMapping(value = PATH) public String error() { return “Error handling”; } @Override public String getErrorPath() { return PATH; } } This is a controller class which has mapping for all the URLs . Step 4: Create application.properties file to define application peroperties server.port=8081 error.whitelabel.enabled=false Step 5: SpringbootDefaultSecurityDemoApplication.java This file will be automatically created by editor when you create the project. You have to run this file in order to bootstrap your spring boot application – package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringbootDefaultSecurityDemoApplication { public static void main(String[] args) { SpringApplication.run(SpringbootDefaultSecurityDemoApplication.class, args); } } When you run the above class , application will be compiled and hosted on to embedded tomcat web server. Step 6: Access the application Now as the application is up and running , you can access the application from browser. You can make sure application is up and running from logs printed onto a console. If some error occurs then your application will not be launched. When you try to access the application from http://localhost:8081/. Then your request will be intercepted by spring security automatically and you will be redirected to default login form as below – You have to enter Username as ‘user‘ and password printed onto console logs . In my case password is – Using generated security password: d58d9d78-7c80-4620-a92b-c93c68c780e7 Once you click on Sign in , you will be redirected to controller action –... Read more...Spring boot + Spring Security in memory authenticationDecember 26, 2018Spring SecurityWe will use Spring boot with spring security as below – We can secure spring application using spring security API provided by spring . Github Link: Download Tools used for below project – Spring Boot 2.0.3.RELEASESpring 5.0.7.RELEASETomcat Embed 8Maven 3.3Java 8Spring Tool Suite IDE (STS) Step 1: Project Structure Step 2: Create a project named SpringBootSpringSecurityDemo in STS (Refer Create new project in STS). Select web , security dependency from starter project dependencies popup – Step 3: Below pom.xml will be generated for you by STS . You need to add JSTL and Embeded tomcat dependency if it’s not present. <?xml version=”1.0″ encoding=”UTF-8″?> <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringBootSpringSecurityDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringBootSpringSecurityDemo</name> <description>Demo project for Spring Boot with spring security</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath /> <!– lookup parent from repository –> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!– https://mvnrepository.com/artifact/org.threeten/threetenbp –> <dependency> <groupId>org.threeten</groupId> <artifactId>threetenbp</artifactId> <version>0.7.2</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a web application, we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-security to provide security to this web application.Let’s do security configuration first. Conroller class- Step 4: Create “HelloController .java” file under com.myjavablog.controller package – package com.myjavablog.controller; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping; /** * @author anupb * */ @Controller public class HelloController { @GetMapping(“/hello”) public String getHomePage(Model model) { model.addAttribute(“message”, “Lets make our app secure”); return “hello”; } } Its a simple controller with only hello method inside it. Below are the annotations used- @Controller – @Controller is used to mark classes as Spring MVC Controller. @GetMapping – This anootation is used map GET requests from browser to java methods. If you run the application at this stage , spring boot will bootstrap spring security and default security will be provided. If you run the application and try to access http://localhost:8081/hello . This request will be intercepted by Spring security and will be redirected to login page as below – Login with default username : user and password generated by spring in below logs – Spring boot main file to bootstrap application – Step 5: Create a “SpringBootSpringSecurityDemoApplication.java” file in package com.myjavablog package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringBootSpringSecurityDemoApplication { public static void main(String[] args) { SpringApplication.run(SpringBootSpringSecurityDemoApplication.class, args); } } This is the main file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work.Let’s understand more about this [email protected] is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application [email protected] – It enables Spring boot to add beans presents in classpath setting and various property setting.Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath.This flags the application as a web application and activates key behaviors such as setting up a [email protected] – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers.If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Step 6: Create a file named “WebSecurityConfiguaration.java” in package com.myjavablog /** * */ package com.myjavablog; /** * @author anupb * */ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.crypto.password.NoOpPasswordEncoder; @Configuration @EnableWebSecurity public class WebSecurityConfiguaration extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin(); } @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication().passwordEncoder(NoOpPasswordEncoder.getInstance()). withUser(“myjavablog”).password(“secure”).roles(“ADMIN”); } } @EnableWebSecurity – Enables security for our application. http.authorizeRequests().antMatchers(“/hello*”) – Secures all the URLs containing hello word in it. http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin() – Allows role based access to these URLs . User with only admin can access this URL. auth.inMemoryAuthentication().withUser(“myjavablog”).password(“secure”).roles(“ADMIN”) – We are using in Memory authentication to authenticate the user. User credentials are stored in memory for this example. We can store them either in database , LDAP etc. When user provides myjavablog/secure credentials in login form then only he can access URLs with /hello as this user has ADMIN role. Step 7: Now create application.properties file inside /src/main/resources folder. spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8081 This is simillar to dispatcher servlet in spring MVC to configure view resolution. Step 8: Create index.jsp inside webapp <%@ page language=”java” contentType=”text/html; charset=UTF-8″ pageEncoding=”UTF-8″%> <%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core”%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <html> <head> <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″> <title>HelloWorld</title> </head> <body> <a href=”hello.html”>Click here to read hello message </a> </br> <a href=”<c:url value=”/logout” />”>Logout</a> </body> </html> Step 9: Create hello.jsp inside webapp/WEB-INF/views <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″ pageEncoding=”ISO-8859-1″%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <html> <head> <meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″> <title>Hello world Page</title> </head> <body> ${message} </body> </html> Run the application Step 10: Right Click on Project -> Debug As -> Maven Build Step 8: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 9: Now go to URL http://localhost:8082/. Index page will open up as below – Once you click on the link, this request will be intercepted by spring security and you will be asked to enter username and password. Home Page –... Read more...MEMENTO PATTERNNovember 24, 2018design patternsMemento pattern is one of the behavioral design patterns. Memento design pattern is used when we want to save the state of an object so that we can restore later on. Memento pattern is used to implement this in such a way that the saved state data of the object is not accessible outside of the object; this protects the integrity of saved state data. Memento pattern is implemented with two objects – Originator and Caretaker. Originator is the object whose state needs to be saved and restored and it uses an inner class to save the state of Object. The inner class is called Memento and its private, so that it can’t be accessed from other objects. Caretaker is the helper class that is responsible for storing and restoring the Originator’s state through Memento object. Since Memento is private to Originator, Caretaker can’t access it and it’s stored as an Object within the caretaker. One of the best real life examples is the text editors where we can save its data anytime and use undo to restore it to previous saved state. We will implement the same feature and provide a utility where we can write and save contents to a File anytime and we can restore it to last saved state. For simplicity, I will not use any IO operations to write data into file. When to use the Memento Pattern: Use the Memento Pattern in the following cases: A snapshot of (some portion of) an object’s state must be saved so that it can be restored to that state later, and A direct interface to obtaining the state would expose implementation details and break the object’s encapsulation Memento Pattern in JDK: java.util.Date java.io.Serializable... Read more...INTERPRETER PATTERNNovember 24, 2018design patternsInterpreter pattern is one of the behavioral design patterns and is used to define a grammatical representation for a language and provides an interpreter to deal with this grammar. The best example of this pattern is java compiler that interprets the java source code into byte code that is understandable by JVM. Google Translator is also an example of interpreter pattern where the input can be in any language and we can get the output interpreted in another language. To implement interpreter pattern, we need to create Interpreter context engine that will do the interpretation work and then we need to create different Expression implementations that will consume the functionalities provided by the interpreter context. Finally we need to create the client that will take the input from user and decide which Expression to use and then generate output for the user. When to use the Interpreter Design Pattern Use the Interpreter pattern when there is a language to interpret, and you can represent statements in the language as abstract syntax trees. The Interpreter pattern works best when The grammar is simple. For complex grammars, the class hierarchy for the grammar becomes large and unmanageable. Tools such as parser generators are a better alternative in such cases. They can interpret expressions without building abstract syntax trees, which can save space and possibly time. Efficiency is not a critical concern. The most efficient interpreters are usually not implemented by interpreting parse trees directly but by first translating them into another form. For example, regular expressions are often transformed into state machines. But even then, the translator can be implemented by the Interpreter pattern, so the pattern is still applicable. Interpreter Design Pattern in JDK: java.util.Pattern java.text.Normalizer java.text.Format... Read more...ITERATOR PATTERNNovember 24, 2018design patternsIterator pattern in one of the behavioral pattern and it’s used to provide a standard way to traverse through a group of Objects. Iterator pattern is widely used in java collection framework where Iterator interface provides methods for traversing through a collection. The logic for iteration is embedded in the collection itself and it helps client program to iterate over them easily. Iterator pattern is not only about traversing through a collection; we can provide different kind of iterators based on our requirements. Iterator pattern hides the actual implementation of traversal through the collection and client programs just use iterator methods. An Iterator object contains public methods to allow a client object to navigate through the list of objects within the container. Iterator Defines an interface for accessing and traversing elements. ConcreteIterator Implements the Iterator interface. Keeps track of the current position in the traversal of the aggregate. Aggregate Defines an interface for creating an Iterator object. ConcreteAggregate Implements the Iterator creation interface to return an instance of the proper ConcreteIterator. When to use the Iterator Design Pattern: Use the Iterator pattern: To access an aggregate object’s contents without exposing its internal representation. To support multiple traversals of aggregate objects. To provide a uniform interface for traversing different aggregate structures (that is, to support polymorphic iteration). Iterator pattern is useful when you want to provide a standard way to iterate over a collection and hide the implementation logic from client program. Iterator Pattern in JDK: java.util.Iterator java.util.Enumeration... Read more...STATE PATTERNNovember 24, 2018design patternsState design pattern is used when an Object change its behavior when it’s internal state changes. The state of an object can be defined as its exact condition at any given point of time, depending on the values of its properties or attributes. The set of methods implemented by a class constitutes the behavior of its instances. Whenever there is a change in the values of its attributes, we say that the state of an object has changed. When a Context object is first created, it initializes itself with its initial State object. This State object becomes the current State object for the context. By replacing the current State object with a new State object, the context transitions to a new state. When an application object makes a call to a Context method (behavior), it forwards the method call to its current State object. Context: Defines the interface of interest to clients. Maintains an instance of a ConcreteState subclass that defines the current state. State: Defines an interface for encapsulating the behavior associated with a particular state of the Context. ConcreteState subclasses: Each subclass implements a behavior associated with a state of the Context. In the state pattern, we have a Context class, and this class has a State reference to a Concrete State instance. The State interface declares particular methods that represent the behaviors of a particular state. Concrete States implement these behaviors. By changing a Context’s Concrete State, we change its behavior. In essence, in the state pattern, a class (the Context) is supposed to behave like different classes depending on its state. The state pattern avoids the use of switch and if statements to change behavior. Example: package com.myjavablog.behavioural.state; public interface MobileState { public void getState(); } package com.myjavablog.behavioural.state; public class Ringing implements MobileState { @Override public void getState() { System.out.println(“Mobile in Ringing state”); } } package com.myjavablog.behavioural.state; public class Vibrate implements MobileState { @Override public void getState() { System.out.println(“Mobile in Vibrate mode”); } } package com.myjavablog.behavioural.state; public class Silent implements MobileState { @Override public void getState() { System.out.println(“Mobile in Silent mode”); } } package com.myjavablog.behavioural.state; public class MobileContext implements MobileState { private MobileState mobileState; public MobileContext(MobileState mobileState) { this.mobileState = mobileState; } public void setMobileState(MobileState mobileState) { this.mobileState = mobileState; } @Override public void getState() { mobileState.getState(); } } package com.myjavablog.behavioural.state; public class StatePatternTest { public static void main(String[] args) { MobileContext context = new MobileContext(new Ringing()); context.getState(); context.getState(); context.setMobileState(new Vibrate()); context.getState(); context.getState(); context.getState(); context.setMobileState(new Silent()); context.getState(); context.getState(); } } Output: Mobile in Ringing state Mobile in Ringing state Mobile in Vibrate mode Mobile in Vibrate mode Mobile in Vibrate mode Mobile in Silent mode Mobile in Silent mode The benefits of using State pattern to implement polymorphic behavior is clearly visible, the chances of error are less and it’s very easy to add more states for additional behavior making it more robust, easily maintainable and flexible. Also State pattern helped in avoiding if-else or switch-case conditional logic in this scenario. When to use the State Design Pattern: Use the State pattern in either of the following cases: An object’s behavior depends on its state, and it must change its behavior at run-time depending on that state. Operations have large, multipart conditional statements that depend on the object’s state. This state is usually represented by one or more enumerated constants. Often, several operations will contain this same conditional structure. The State pattern puts each branch of the conditional in a separate class. This lets you treat the object’s state as an object in its own right that can vary independently from other objects. State Design Pattern in Java: javax.faces.lifecycle.LifeCycle#execute ()... Read more...VISITOR PATTERNNovember 24, 2018design patternsVisitor pattern is used when we have to perform an operation on a group of similar kind of Objects. With the help of visitor pattern, we can move the operational logic from the objects to another class. For example, think of a Shopping cart where we can add different type of items (Elements), when we click on checkout button, it calculates the total amount to be paid. Now we can have the calculation logic in item classes or we can move out this logic to another class using visitor pattern. So using visitor pattern we can move out logics to another class. The Visitor pattern allows the operation to be defined without changing the class of any of the objects in the collection. To accomplish this, the Visitor pattern suggests defining the operation in a separate class referred to as a visitor class. This separates the operation from the object collection that it operates on. For every new operation to be defined, a new visitor class is created. Since the operation is to be performed across a set of objects, the visitor needs a way of accessing the public members of these objects. Following components are involved in visitor pattern- Visitor: Declares a Visit operation for each class of ConcreteElement in the object structure. The operation’s name and signature identifies the class that sends the Visit request to the visitor. That lets the visitor determine the concrete class of the element being visited. Then the visitor can access the element directly through its particular interface. ConcreteVisitor: Implements each operation declared by Visitor. Each operation implements a fragment of the algorithm defined for the corresponding class of object in the structure. ConcreteVisitor provides the context for the algorithm and stores its local state. This state often accumulates results during the traversal of the structure. Element: Defines an Accept operation that takes a visitor as an argument. ConcreteElement: Implements an Accept operation that takes a visitor as an argument. ObjectStructure: Can enumerate its elements. May provide a high-level interface to allow the visitor to visit its elements. May either be a composite or a collection such as a list or a set. To implement visitor pattern, first of all we will create different type of items (Elements) to be used in shopping cart. Example: package com.myjavablog.behavioural.visitor; public interface ShoppingCartElement { //accept method takes Visitor argument public int accept(ShoppingCartVisitor visitor); } Let’s create some concrete classes for different types of item. package com.myjavablog.behavioural.visitor; public class Book implements ShoppingCartElement { private int price; private String isbnNumber; public Book(int price, String isbnNumber) { this.price = price; this.isbnNumber = isbnNumber; } public int getPrice() { return price; } public String getIsbnNumber() { return isbnNumber; } @Override public int accept(ShoppingCartVisitor visitor) { return visitor.visit(this); } } package com.myjavablog.behavioural.visitor; public class Fruit implements ShoppingCartElement { private int pricePerKg; private int weight; private String name; public Fruit(int pricePerKg, int weight, String name) { this.pricePerKg = pricePerKg; this.weight = weight; this.name = name; } public int getPricePerKg() { return pricePerKg; } public int getWeight() { return weight; } public String getName() { return name; } @Override public int accept(ShoppingCartVisitor visitor) { return visitor.visit(this); } } We have visit () method for different type of items in Visitor interface that will be implemented by concrete visitor class. package com.myjavablog.behavioural.visitor; public interface ShoppingCartVisitor { int visit(Book book); int visit(Fruit fruit); } Now we will implement visitor interface and every item will have its own logic to calculate the cost. package com.myjavablog.behavioural.visitor; public class ShoppingCartVisitorImpl implements ShoppingCartVisitor { @Override public int visit(Book book) { int cost = 0; //Apply discount if book price is greator than 50 if(book.getPrice() > 50){ cost = book.getPrice() – 5; }else{ cost = book.getPrice(); } System.out.println(“Book IBSN Number: “+ book.getIsbnNumber() +” Cost : “+ cost ); return cost; } @Override public int visit(Fruit fruit) { int cost =0; cost = fruit.getPricePerKg() * fruit.getWeight(); System.out.println(“Fruit Name: “+ fruit.getName() +” Cost: “+ cost); return cost; } } Let’s see how we can use it in client applications. package com.myjavablog.behavioural.visitor; public class VisitorPatternTest { public static void main(String[] args) { ShoppingCartElement[] items = new ShoppingCartElement[]{new Book(100, “You can win”), new Fruit(100, 2, “Apple” ), new Book(200, “Five Point Someone”), new Fruit(40, 4, “Gauva”)}; System.out.println(“Total cost: “+ VisitorPatternTest.calculatePrice(items)); } public static int calculatePrice(ShoppingCartElement[] items){ ShoppingCartVisitor visitor = new ShoppingCartVisitorImpl(); int sum = 0; for(ShoppingCartElement element : items){ sum = sum + element.accept(visitor); } return sum; } } Output: Book IBSN Number: You can win Cost : 95 Fruit Name: Apple Cost: 200 Book IBSN Number: Five Point Someone Cost : 195 Fruit Name: Gauva Cost: 160 Total cost: 650 The benefit of this pattern is that if the logic of operation changes, then we need to make change only in the visitor implementation rather than doing it in all the item classes. When to use the Visitor Design Pattern: Use the Visitor pattern when: An object structure contains many classes of objects with differing interfaces, and you want to perform operations on these objects that depend on their concrete classes. Many distinct and unrelated operations need to be performed on objects in an object structure, and you want to avoid “polluting” their classes with these operations. Visitor lets you keep related operations together by defining them in one class. When the object structure is shared by many applications, use Visitor to put operations in just those applications that need them. The classes defining the object structure rarely change, but you often want to define new operations over the structure. Changing the object structure classes requires redefining the interface to all visitors, which is potentially costly. If the object structure classes change often, then it’s probably better to define the operations in those classes. Visitor Design Pattern in JDK: javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor... Read more...COMMAND PATTERNNovember 24, 2018design patternsThe command pattern is a behavioral object design pattern. In the command pattern, a Command interface declares a method for executing a particular action. Concrete Command classes implement the execute () method of the Command interface, and this execute () method invokes the appropriate action method of a Receiver class that the Concrete Command class contains. The Receiver class performs a particular action. A Client class is responsible for creating a Concrete Command and setting the Receiver of the Concrete Command. An Invoker class contains a reference to a Command and has a method to execute the Command. In the command pattern, the invoker is decoupled from the action performed by the receiver. The invoker has no knowledge of the receiver. The invoker invokes a command, and the command executes the appropriate action of the receiver. Thus, the invoker can invoke commands without knowing the details of the action to be performed. In addition, this decoupling means that changes to the receiver’s action don’t directly affect the invocation of the action. The command pattern can be used to perform ‘undo’ functionality. In this case, the Command interface should include an unexecuted () method. In other words, it’s used to implement lose coupling in a request-response model. In command pattern, the request is send to the invoker and invoker passes it to the encapsulated command object. Command object passes the request to the appropriate method of Receiver to perform the specific action. The client program creates the receiver object and then attaches it to the Command. Then it creates the invoker object and attaches the command object to perform an action. Now when client program executes the action, it’s processed based on the command and receiver object. To understand command design pattern we should understand the associated key terms like client, command, command implementation, invoker, and receiver. Command is an interface with execute method. It is the core of contract. A client creates an instance of a command implementation and associates it with a receiver. An invoker instructs the command to perform an action. A Command implementation’s instance creates a binding between the receiver and an action. Receiver is the object that knows the actual steps to perform the action. Any class may serve as a Receiver. Example: package com.myjavablog.behavioural.command; //Command interface with an execute method public interface Command { public void execute(); } package com.myjavablog.behavioural.command; //Lunch is a receiver public class Lunch { public void makeLunch(){ System.out.println(“Lunch is being made”); } } package com.myjavablog.behavioural.command; //LunchCommand implements Command. It contains reference to Lunch ,a receviver. //Its execute method invokes appropriate action on receiver public class LunchCommand implements Command{ Lunch lunch; public LunchCommand(Lunch lunch){ this.lunch = lunch; } @Override public void execute() { lunch.makeLunch(); } } package com.myjavablog.behavioural.command; //Dinner is a receiver public class Dinner { public void makeDinner() { System.out.println(“Dinner is being made”); } } package com.myjavablog.behavioural.command; //DinnerCommand also implements Command. It contains reference to Dinner ,a receviver. //Its execute method invokes appropriate action on receiver public class DinnerCommand implements Command{ Dinner dinner; public DinnerCommand(Dinner dinner){ this.dinner = dinner; } @Override public void execute() { dinner.makeDinner(); } } package com.myjavablog.behavioural.command; //MealInvoker is invoker class //It contains reference to command to invoke //Its invoke method calls execute method of command public class MealInvoker { Command command; public MealInvoker(Command command){ this.command = command; } public void setCommand(Command command){ this.command = command; } public void invoke(){ command.execute(); } } package com.myjavablog.behavioural.command; public class CommandPatternDemo { public static void main(String[] args) { Lunch lunch = new Lunch(); //Receiver Command lunchCommand = new LunchCommand(lunch); //Concrete command Dinner dinner = new Dinner(); //Receiver Command dinnerCommand = new DinnerCommand(dinner); //Concrete command MealInvoker mealInvoker = new MealInvoker(lunchCommand); //invoker mealInvoker.invoke(); mealInvoker.setCommand(dinnerCommand); mealInvoker.invoke(); } } Output: Lunch is being made Dinner is being made When to use the Command Design Pattern: Use the Command pattern when you want to: Parameterize objects by an action to perform. Support undo. The Command’s Execute operation can store state for reversing its effects in the command itself. The Command interface must have an added Un-execute operation that reverses the effects of a previous call to Execute. Executed commands are stored in a history list. Unlimited-level undo and redo is achieved by traversing this list backwards and forwards calling Un-execute and Execute, respectively. Structure a system around high-level operations built on primitives operations. Such a structure is common in information systems that support transactions. The Command pattern offers a way to model transactions. Commands have a common interface, letting you invoke all transactions the same way. The pattern also makes it easy to extend the system with new transactions. Command Pattern JDK Example: Runnable Interface (java.lang.Runnable) and Swing Action (javax.swing.Action) uses command pattern.... Read more...STRATEGY PATTERNNovember 24, 2018design patternsThe Strategy pattern is useful when there is a set of related algorithms and a client object needs to be able to dynamically pick and choose an algorithm from this set that suits its current need. The Strategy pattern suggests keeping the implementation of each of the algorithms in a separate class. Each such algorithm encapsulated in a separate class is referred to as a strategy. An object that uses a Strategy object is often referred to as a context object. In other words, Strategy pattern is used when we have multiple algorithms for a specific task and client decides the actual implementation to be used at runtime. Strategy pattern is also known as Policy Pattern. We define multiple algorithms and let client application pass the algorithm to be used as a parameter. One of the best example of this pattern is Collections.sort () method that takes Comparator parameter. Based on the different implementations of Comparator interfaces, the Objects are getting sorted in different ways. The strategy pattern is one way that composition can be used as an alternative to subclassing. Rather than providing different behaviors via subclasses overriding methods in super classes, the strategy pattern allows different behaviors to be placed in Concrete Strategy classes which share the common Strategy interface. A Context object contains a reference to a Strategy. By changing the Context’s Strategy, different behaviors can be obtained. Example: package com.myjavablog.behavioural.strategy; public interface Strategy { public void sort(int[] numbers); } package com.myjavablog.behavioural.strategy; public class Context { private Strategy strategy; Context(Strategy strategy){ this.strategy = strategy; } public void arrange(int[] input) { strategy.sort(input); } } package com.myjavablog.behavioural.strategy; public class BubbleSort implements Strategy { @Override public void sort(int[] numbers) { System.out.println(“Sorted using bubble sort!!”); } } package com.myjavablog.behavioural.strategy; public class MergeSort implements Strategy { @Override public void sort(int[] numbers) { System.out.println(“Sorted using Merge sort!!”); } } package com.myjavablog.behavioural.strategy; public class InsertionSort implements Strategy { @Override public void sort(int[] numbers) { System.out.println(“Sorted using Insertion sort!!”); } } package com.myjavablog.behavioural.strategy; public class StrategyPatternTest { public static void main(String[] args) { int[] var = {2, 4, 1, 3 , 9, 6}; //We can provide any strategy for sorting Context ctx = new Context(new BubbleSort()); ctx.arrange(var); //We can change the strategy without changing Context class ctx = new Context(new MergeSort()); ctx.arrange(var); } } Output: Sorted using bubble sort!! Sorted using Merge sort!! When to use the Strategy Design Pattern: Use the Strategy pattern when: Many related classes differ only in their behavior. Strategies provide a way to configure a class with one of many behaviors. You need different variants of an algorithm. For example, you might define algorithms reflecting different space/time trade-offs. Strategies can be used when these variants are implemented as a class hierarchy of algorithms. An algorithm uses data that clients shouldn’t know about. Use the Strategy pattern to avoid exposing complex, algorithm-specific data structures. A class defines many behaviors, and these appear as multiple conditional statements in its operations. Instead of many conditionals, move related conditional branches into their own Strategy class. Strategy Pattern in JDK: java.util.Comparator#compare () javax.servlet.http.HttpServlet javax.servlet.Filter#doFilter ()... Read more...OBSERVER PATTERNNovember 24, 2018design patternsIn observer design pattern multiple observer objects registers with a subject for change notification. When the state of subject changes, it notifies the observers. Objects that listen or watch for change are called observers and the object that is being watched for is called subject. Pattern involved is also called as publish-subscribe pattern. Subject provides interface for observers to register and unregister themselves with the subject. Subject knows who its subscribers are. Multiple observers can subscribe for notifications. Subject publishes the notifications. Subject just sends the notification saying the state has changed. It does not pass any state information. Once the notification is received from subject, observers call the subject and get data that is changed. The above last two points are not strictly followed in observer design pattern implementation. Along with the notification, state is also passed in some implementation so that the observer need not query back to know the status. It is better not to do this way. There are four participants in the Observer pattern: * Subject, which is used to register observers. Objects use this interface to register as observers and also to remove themselves from being observers. * Observer defines an updating interface for objects that should be notified of changes in a subject. All observers need to implement the Observer interface. This interface has a method update (), which gets called when the Subject’s state changes. * ConcreteSubject, stores the state of interest to ConcreteObserver objects. It sends a notification to its observers when its state changes. A concrete subject always implements the Subject interface. The notifyObservers () method is used to update all the current observers whenever the state changes. * ConcreateObserver maintains a reference to a ConcreteSubject object and implements the Observer interface. Each observer registers with a concrete subject to receive updates. Java provides inbuilt platform for implementing Observer pattern through java.util.Observable class and java.util.Observer interface. However it’s not widely used because the implementation is really simple and most of the times we don’t want to end up extending a class just for implementing Observer pattern as java doesn’t provide multiple inheritances in classes. Example: Let us take a blog and subscriber example for observer design pattern sample implementation. Assume that there is a blog and users register to that blog for update. When a new article is posted in the blog, it will send update to the registered users saying a new article is posted. Then the user will access the blog and read the new article posted. In this example, blog is the subject and user is the observer. package com.myjavablog.behavioural.observer; public interface Subject { public void registerObserver(Observer observer); public void notifyObserver(); public void unregisterObserver(Observer observer); public Object getUpdate(); } package com.myjavablog.behavioural.observer; public interface Observer { public void update(); public void setSubject(Subject sub); } package com.myjavablog.behavioural.observer; import java.util.ArrayList; import java.util.List; //Concrete Subject public class Blog implements Subject { List<Observer> observerList; private boolean stateChange; public Blog(){ this.observerList = new ArrayList<>(); stateChange = false; } @Override public void registerObserver(Observer observer) { observerList.add(observer); } @Override public void notifyObserver() { if(stateChange){ for(Observer observer: observerList){ observer.update(); System.out.println(“Observer notified!!”); } } } @Override public void unregisterObserver(Observer observer) { observerList.remove(observer); } @Override public Object getUpdate() { Object changedState = null; //Should have a logic to send state change to the querying observer if(stateChange){ changedState = “Observer Design Pattern”; } return changedState; } public void postNewArticle(){ stateChange = true; notifyObserver(); } } package com.myjavablog.behavioural.observer; //Concrete Observer public class User implements Observer { private String article; private Subject blog; @Override public void update() { System.out.println(“State change reported by subject”); article = (String) blog.getUpdate(); } @Override public void setSubject(Subject blog) { this.blog = blog; article = “No new article!”; } public String getArticle(){ return article; } } package com.myjavablog.behavioural.observer; public class ObserverPatternTest { public static void main(String[] args) { Blog blog = new Blog(); User user1 = new User(); User user2 = new User(); blog.registerObserver(user1); blog.registerObserver(user2); user1.setSubject(blog); user2.setSubject(blog); System.out.println(user1.getArticle()); blog.postNewArticle(); System.out.println(user1.getArticle()); } } Output: No new article! State change reported by subject Observer notified!! State change reported by subject Observer notified!! Observer Design Pattern When to use the Observer Pattern: Use the Observer pattern in any of the following situations: When an abstraction has two aspects, one dependent on the other. Encapsulating these aspects in separate objects lets you vary and reuse them independently. When a change to one object requires changing others, and you don’t know how many objects need to be changed? When an object should be able to notify other objects without making assumptions about who these objects are. In other words, you don’t want these objects tightly coupled. Usage in Java: java.util.EventListener in Swing javax.servlet.http.HttpSessionBindingListener javax.servlet.http.HttpSessionAttributeListener ... Read more...CHAIN OF RESPONSIBILITYNovember 24, 2018design patternsChain of responsibility pattern is used to achieve lose coupling in software design where a request from client is passed to a chain of objects to process them. Then the object in the chain will decide themselves who will be processing the request and whether the request is required to be sent to the next object in the chain or not. When there is more than one objects that can handle or fulfill a client request, the pattern recommends giving each of these objects a chance to process the request in some sequential order. Applying the pattern in such a case, each of these potential handlers can be arranged in the form of a chain, with each object having a reference to the next object in the chain. The first object in the chain receives the request and decides either to handle the request or to pass it on to the next object in the chain. The request flows through all objects in the chain one after the other until the request is handled by one of the handlers in the chain or the request reaches the end of the chain without getting processed. Let’s see the example of chain of responsibility pattern in JDK and then we will proceed to implement a real life example of this pattern. We know that we can have multiple catch blocks in a try-catch block code. Here every catch block is kind of a processor to process that particular exception. So when any exception occurs in the try block its send to the first catch block to process. If the catch block is not able to process it, it forwards the request to next object in chain i.e. next catch block. If even the last catch block is not able to process it, the exception is thrown outside of the chain to the calling program. Other examples are ATM money dispenser, Servlet Filter and finally java’s own Exception Handling mechanism. We know exception handling better than anybody else and we are daily living with it. This qualifies as the best example for chain of responsibility. Example: In ATM Dispense machine, the user enters the amount to be dispensed and the machine dispense amount in terms of defined currency bills such as 50$, 20$, 10$ etc. If the user enters an amount that is not multiples of 10, it throws error. package com.myjavablog.behavioural.COR; //This class is a request object. public class Number { private int number; public int getNumber(){ return number; } public Number(int number){ this.number = number; } } package com.myjavablog.behavioural.COR; //This interface acts as a chain link public interface Chain { public void setNext(Chain nextInChain); public void process(Number request); } package com.myjavablog.behavioural.COR; public class PositiveNumberProcessor implements Chain { private Chain nextInChain; @Override public void setNext(Chain c) { this.nextInChain = c; } @Override public void process(Number request) { if(request.getNumber() > 0){ System.out.println(“PositiveNumberProcessor : “+ request.getNumber()); }else { nextInChain.process(request); } } } package com.myjavablog.behavioural.COR; public class NegativeNumberProcessor implements Chain { private Chain nextInChain; @Override public void setNext(Chain c) { this.nextInChain = c; } @Override public void process(Number request) { if(request.getNumber() < 0){ System.out.println(“NegativeNumberProcessor : “+ request.getNumber()); }else { nextInChain.process(request); } } } package com.myjavablog.behavioural.COR; public class ZeroProcessor implements Chain { private Chain nextInChain; @Override public void setNext(Chain c) { this.nextInChain = c; } @Override public void process(Number request) { if(request.getNumber() == 0){ System.out.println(“ZeroProcessor : “+ request.getNumber()); }else { nextInChain.process(request); } } } package com.myjavablog.behavioural.COR; public class CORPatternTest { public static void main(String[] args) { //Configure chain of responsibility Chain c1 = new NegativeNumberProcessor(); Chain c2 = new ZeroProcessor(); Chain c3 = new PositiveNumberProcessor(); c1.setNext(c2); c2.setNext(c3); //Calling chain of responsibility c1.process(new Number(99)); c1.process(new Number(-76)); c1.process(new Number(0)); c1.process(new Number(100)); } } Output: PositiveNumberProcessor : 99 NegativeNumberProcessor : -76 ZeroProcessor : 0 PositiveNumberProcessor : 100 When to use the Chain of Responsibility Pattern: Use Chain of Responsibility when More than one object may handle a request, and the handler isn’t known a priority. The handler should be ascertained automatically. You want to issue a request to one of several objects without specifying the receiver explicitly. The set of objects that can handle a request should be specified dynamically. Chain of Responsibility Pattern Examples in JDK: java.util.logging.Logger#log () javax.servlet.Filter#doFilter ()... Read more...MEDIATOR PATTERNNovember 18, 2018design patternsMediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. Mediator design pattern is used to provide a centralized communication medium between different objects in a system. Rather than interacting directly with each other, objects ask the Mediator to interact on their behalf which results in reusability and loose coupling. It encapsulates the interaction between the objects and makes them independent from each other. This allows them to vary their interaction with other objects in a totally different way by implementing a different mediator. The Mediator helps to reduce the complexity of the classes. Each object no longer has to know in detail about how to interact with the other objects. The coupling between objects goes from tight and brittle to loose and agile. Mediator design pattern is very helpful in an enterprise application where multiple objects are interacting with each other. If the objects interact with each other directly, the system components are tightly-coupled with each other that make maintainability cost higher and not flexible to extend easily. Mediator pattern focuses on providing a mediator between objects for communication and help in implementing lose-coupling between objects. Air traffic controller is a great example of mediator pattern where the airport control room works as a mediator for communication between different flights. Mediator works as a router between objects and it can have its own logic to provide way of communication. The major participants of the Mediator Pattern are: Mediator: Defines an interface for communicating with Colleague objects. ConcreteMediator: Implements co-operative behavior by coordinating Colleague objects. It also knows and maintains its colleagues. Colleague Classes: Each Colleague class knows its Mediator objects. Each colleague communicates with its mediator whenever it would have otherwise communicated with another colleague. Example: package com.myjavablog.behavioural.mediator; public interface IMediator { public void talk(); public void fight(); public void registerA(ColleagueA a); public void registerB(ColleagueB b); } package com.myjavablog.behavioural.mediator; public class ConcreteMediator implements IMediator { ColleagueA talk; ColleagueB fight; @Override public void talk() { System.out.println(“Mediator is talking”); //Talk colleague doing some stuff } @Override public void fight() { System.out.println(“Mediator is fighting”); //Fight colleague doing some stuff } @Override public void registerA(ColleagueA a) { this.talk =a; } @Override public void registerB(ColleagueB b) { this.fight =b; } } package com.myjavablog.behavioural.mediator; public abstract class Colleague { IMediator mediator; public abstract void doSomething(); } package com.myjavablog.behavioural.mediator; public class ColleagueA extends Colleague{ ColleagueA(IMediator mediator){ this.mediator = mediator; this.mediator.registerA(this); } @Override public void doSomething() { this.mediator.talk(); } } package com.myjavablog.behavioural.mediator; public class ColleagueB extends Colleague{ ColleagueB(IMediator mediator){ this.mediator = mediator; this.mediator.registerB(this); } @Override public void doSomething() { this.mediator.fight(); } } package com.myjavablog.behavioural.mediator; public class MediatorPatternTest { public static void main(String[] args) { IMediator mediator = new ConcreteMediator(); ColleagueA talkColleague = new ColleagueA(mediator); talkColleague.doSomething(); ColleagueB fightColleague = new ColleagueB(mediator); fightColleague.doSomething(); } } Output: Mediator is talking Mediator is fighting When to use the Mediator Pattern: A set of objects communicate in well-defined but complex ways. The resulting interdependencies are unstructured and difficult to understand. Reusing an object is difficult because it refers to and communicates with many other objects. A behavior that’s distributed between several classes should be customizable without a lot of sub-classing. Mediator Pattern in JDK: java.util.Timer class scheduleXXX () methods. java Concurrency Executor execute () method. java.lang.reflect.Method invoke () method. ... Read more...TEMPLATE METHOD PATTERNNovember 13, 2018design patternsThe Template Pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses to redefine certain steps of an algorithm without changing the algorithm’s structure. The Template Method pattern can be used in situations when there is an algorithm, some steps of which could be implemented in multiple different ways. In such scenarios, the Template Method pattern suggests keeping the outline of the algorithm in a separate method referred to as a template method inside a class, which may be referred to as a template class, leaving out the specific implementations of the variant portions (steps that can be implemented in multiple different ways) of the algorithm to different subclasses of this class. The Template class does not necessarily have to leave the implementation to subclasses in its entirety. Instead, as part of providing the outline of the algorithm, the Template class can also provide some amount of implementation that can be considered as invariant across different implementations. It can even provide default implementation for the variant parts, if appropriate. Only specific details will be implemented inside different subclasses. This type of implementation eliminates the need for duplicate code, which means a minimum amount of code to be written. Template method should consist of certain steps whose order is fixed and for some of the methods; implementation differs from base class to subclass. Template method should be final. Most of the times, subclasses calls methods from super class but in template pattern, superclass template method calls methods from subclasses, this is known as Hollywood Principle – “don’t call us, we’ll call you.” Methods in base class with default implementation are referred as Hooks and they are intended to be overridden by subclasses, if you want some of the methods to be not overridden, you can make them final, for example in our case we can make doPack () method final because if we don’t want subclasses to override it. package com.myjavablog.behavioural.template; public abstract class PurchaseOrderTemplate { public abstract void doSelect(); public abstract void doPayment(); public final void doPack(){ System.out.println(“Gift wrapping done.”); } public abstract void doDelivery(); public final void processOrder(){ doSelect(); doPayment(); doPack(); doDelivery(); } } package com.myjavablog.behavioural.template; public class StorePurchaseOrder extends PurchaseOrderTemplate{ @Override public void doSelect() { System.out.println(“Customer selects item from shelf”); } @Override public void doPayment() { System.out.println(“Pay at counter through Cash/POS”); } @Override public void doDelivery() { System.out.println(“Item delivered to delivery counter”); } } package com.myjavablog.behavioural.template; public class OnlinePurchaseOrder extends PurchaseOrderTemplate{ @Override public void doSelect() { System.out.println(“Item added to online shopping cart”); System.out.println(“Get gift wrap preference”); System.out.println(“Get delivery address”); } @Override public void doPayment() { System.out.println(“Online Payment through Netbanking/Card”); } @Override public void doDelivery() { System.out.println(“Ship the item through post to delivery address”); } } package com.myjavablog.behavioural.template; public class TemplateMethodPatternTest { public static void main(String[] args) { PurchaseOrderTemplate offline = new StorePurchaseOrder(); System.out.println(“=======Shopping Offline========”); offline.processOrder(); PurchaseOrderTemplate online = new OnlinePurchaseOrder(); System.out.println(“\n=======Shopping Online========”); online.processOrder(); } } Output: =======Shopping Offline======== Customer selects item from shelf Pay at counter through Cash/POS Gift wrapping done. Item delivered to delivery counter =======Shopping Online======== Item added to online shopping cart Get gift wrap preference Get delivery address Online Payment through Netbanking/Card Gift wrapping done. Ship the item through post to delivery address When to use the Template Design Pattern: To implement the invariant parts of an algorithm once and leave it up to subclasses to implement the behavior that can vary. When common behavior among subclasses should be factored and localized in a common class to avoid code duplication. You first identify the differences in the existing code and then separate the differences into new operations. Finally, you replace the differing code with a template method that calls one of these new operations. Usage in JDK: All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer. e.g. – java.io.InputStream#skip (), java.io.InputStream#read () All non-abstract methods of java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap. e.g. – java.util.AbstractList#indexOf (), java.util.Collections#sort ()... Read more...FLYWEIGHT PATTERNNovember 13, 2018design patternsIn the flyweight pattern, instead of creating large numbers of similar objects, objects are reused. This can be used to reduce memory requirements and instantiation time and related costs. Flyweight design pattern is used when we need to create a lot of Objects of a class. Since every object consumes memory space that can be crucial for low memory devices, such as mobile devices or embedded systems, flyweight design pattern can be applied to reduce the load on memory by sharing objects. Before we apply flyweight design pattern, we need to consider following factors: The number of Objects to be created by application should be huge. The object creation is heavy on memory and it can be time consuming too. Sometimes too many objects can slow things down. Too many objects might consume a large piece of memory and can slow down the application or even cause out of memory problems. As a good programmer, one should keep track of instantiated objects and control the object creation in an application. This is especially true, when we have a lot of similar objects and two objects from the pool don’t have many differences between them. Sometimes the objects in an application might have great similarities and be of a similar kind (a similar kind here means that most of their properties have similar values and only a few of them vary in value). In case they are also heavy objects to create, they should be controlled by the application developer. Otherwise, they might consume much of the memory and eventually slow down the whole application. The Flyweight Pattern is designed to control such kind of object creation and provides you with a basic caching mechanism. It allows you to create one object per type (the type here differs by a property of that object), and if you ask for an object with the same property (already created), it will return you the same object instead of creating a new one. Flyweight Pattern Example in JDK: All the wrapper classes valueOf () method uses cached objects showing use of Flyweight design pattern. The best example is Java String class String Pool implementation.... Read more...DECORATOR PATTERNNovember 13, 2018design patternsThe intent of the Decorator Design Pattern is to attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality. The Decorator Pattern is used to extend the functionality of an object dynamically without having to change the original class source or using inheritance. This is accomplished by creating an object wrapper referred to as a Decorator around the actual object. The Decorator object is designed to have the same interface as the underlying object. This allows a client object to interact with the Decorator object in exactly the same manner as it would with the underlying actual object. The Decorator object contains a reference to the actual object. The Decorator object receives all requests (calls) from a client. In turn, it forwards these calls to the underlying object. The Decorator object adds some additional functionality before or after forwarding requests to the underlying object. This ensures that the additional functionality can be added to a given object externally at runtime without modifying its structure. We use inheritance or composition to extend the behavior of an object but this is done at compile time and it’s applicable to all the instances of the class. We can’t add any new functionality of remove any existing behavior at runtime – this is when Decorator pattern comes into picture. Component Interface – The interface or abstract class defining the methods that will be implemented. In our case Icecream will be the component interface. package com.myjavablog.structural.decorator; public interface Icecream { public String makeIcecream(); } Component Implementation – The basic implementation of the component interface. We can have SimpleIcecream class as our component implementation. package com.myjavablog.structural.decorator; public class SimpleIcecream implements Icecream { @Override public String makeIcecream() { return “Base Icecream”; } } Decorator – Decorator class implements the component interface and it has a HAS-A relationship with the component interface. The component variable should be accessible to the child decorator classes, so we will make this variable protected. package com.myjavablog.structural.decorator; public class IcecreamDecorator implements Icecream { protected Icecream specialIcecream; public IcecreamDecorator(Icecream specialIcecream) { this.specialIcecream = specialIcecream; } @Override public String makeIcecream() { return specialIcecream.makeIcecream(); } } Concrete Decorators – Extending the base decorator functionality and modifying the component behavior accordingly. We can have concrete decorator classes as NuttyIcecreamDecorator & HoneyIcecreamDecorator. package com.myjavablog.structural.decorator; public class NuttyDecorator extends IcecreamDecorator { public NuttyDecorator(Icecream specialIcecream) { super(specialIcecream); } public String makeIceCream(){ return specialIcecream.makeIcecream() + addNuts(); } public String addNuts(){ return “+ Crunchy Nuts “; } } package com.myjavablog.structural.decorator; public class HoneyDecorator extends IcecreamDecorator { public HoneyDecorator(Icecream specialIcecream) { super(specialIcecream); } public String makeIceCream() { return specialIcecream.makeIcecream() + addHoney(); } public String addHoney() { return “+ Honey sweetner “; } } package com.myjavablog.structural.decorator; public class DecoratorPatternTest { public static void main(String[] args) { Icecream icecream = new HoneyDecorator(new NuttyDecorator(new SimpleIcecream())); System.out.println(icecream.makeIcecream()); } } Output: Base Icecream + Crunchy Nuts + Honey sweetner When to use the Decorator Design Pattern: Use the Decorator pattern in the following cases: To add responsibilities to individual objects dynamically and transparently, that is, without affecting other objects. For responsibilities that can be withdrawn. When extension by sub-classing is impractical. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for sub-classing. It’s easy to maintain and extend when the number of choices are more. Usage in Java: Decorator pattern is used a lot in Java IO classes, such as FileReader, BufferedReader etc. The disadvantage of decorator pattern is that it uses a lot of similar kind of objects (decorators).... Read more...BRIDGE PATTERNNovember 13, 2018design patternsWhen we have interface hierarchies in both interfaces as well as implementations, then builder design pattern is used to decouple the interfaces from implementation and hiding the implementation details from the client programs. According to GoF bridge design pattern is: Decouple an abstraction from its implementation so that the two can vary independently. In the bridge pattern, we separate an abstraction and its implementation and develop separate inheritance structures for both the abstraction and the implementer. The abstraction is an interface or abstract class, and the implementer is likewise an interface or abstract class. The abstraction contains a reference to the implementer. Children of the abstraction are referred to as refined abstractions, and children of the implementer are concrete implementers. Since we can change the reference to the implementer in the abstraction, we are able to change the abstraction’s implementer at run-time. Changes to the implementer do not affect client code. The Bridge Pattern’s intent is to decouple an abstraction from its implementation so that the two can vary independently. It puts the abstraction and implementation into two different class hierarchies so that both can be extend independently. BEFORE BRIDGE DESIGN PATTERN AFTER BRIDGE DESIGN PATTERN The adapter design pattern helps in making two incompatible classes to work together. But, bridge design pattern decouples the abstraction and implementation by creating two different hierarchies. package com.myjavablog.structural.bridge; //Abstraction in bridge pattern public abstract class Vehicle { protected VehicleType type1; protected VehicleType type2; public Vehicle(VehicleType type1, VehicleType type2) { this.type1 = type1; this.type2 = type2; } abstract public void purchase(); } package com.myjavablog.structural.bridge; //Refine abstraction-1 in bridge pattern public class Car extends Vehicle { public Car(VehicleType type1, VehicleType type2) { super(type1, type2); } @Override public void purchase() { System.out.println(“Car”); type1.book(); type2.book(); } } package com.myjavablog.structural.bridge; //Refine abstraction-2 in bridge pattern public class Bike extends Vehicle { public Bike(VehicleType type1, VehicleType type2) { super(type1, type2); } @Override public void purchase() { System.out.println(“Bike”); type1.book(); type2.book(); } } package com.myjavablog.structural.bridge; //Implementor for bridge pattern public interface VehicleType { public void book(); } package com.myjavablog.structural.bridge; //Concrete implementation 1 for bridge pattern public class NewVehicle implements VehicleType { @Override public void book() { System.out.println(“New vehicle”); } } package com.myjavablog.structural.bridge; //Concrete implementation 2 for bridge pattern public class OldVehicle implements VehicleType { @Override public void book() { System.out.println(“Old vehicle”); } } package com.myjavablog.structural.bridge; public class BridgePatternTest { public static void main(String[] args) { Vehicle v1 = new Car(new NewVehicle(), new OldVehicle()); v1.purchase(); Bike b1 = new Bike(new NewVehicle(), new OldVehicle()); b1.purchase(); } } Output: Car New vehicle Old vehicle Bike New vehicle Old vehicle Summary of Bridge Design Pattern: Creates two different hierarchies. One for abstraction and another for implementation. Avoids permanent binding by removing the dependency between abstraction and implementation. We create a bridge that coordinates between abstraction and implementation. Abstraction and implementation can be extended separately. Should be used when we have needed to switch implementation at runtime. Client should not be impacted if there is modification in implementation of abstraction. Best used when you have multiple implementations. Usage in JDK: AWT (It provides an abstraction layer which maps onto the native OS the windowing support.) JDBC... Read more...FACADE PATTERNOctober 28, 2018design patternsThe facade pattern is a structural design pattern. In the facade pattern, a facade classes is used to provide a single interface to set of classes. The facade simplifies a client’s interaction with a complex system by localizing the interactions into a single interface. As a result, the client can interact with a single object rather than being required to interact directly in complicated ways with the objects that make up the subsystem. According to GoF Facade design pattern is: Provide a unified interface to a set of interfaces in a subsystem. Facade Pattern defines a higher-level interface that makes the subsystem easier to use. The Facade does not encapsulate the subsystem classes or interfaces; it just provides a simplified interface to their functionality. A client can access these classes directly. It still exposes the full functionality of the system for the clients who may need it. It just provides a layer to the complex interfaces of the sub-system which makes it easier to use. Facade design pattern is one among the other design patterns that promote loose coupling. It emphasizes one more important aspect of design which is abstraction. By hiding the complexity behind it and exposing a simple interface it achieves abstraction. Facade can wrap multiple classes, but a facade is used to an interface to simplify the use of the complex interface, whereas, an adapter is used to convert the interface to an interface the client expects. Mediator design pattern may look very similar to facade design pattern in terms of abstraction. Mediator abstracts the functionality of the subsystems in this way it is similar to the facade pattern. In the implementation of mediator pattern, subsystem or peers components are aware of the mediator and that interact with it. In the case of facade pattern, subsystems are not aware of the existence of facade. Only facade talks to the subsystems. Example: package com.myjavablog.structural.facade; public class Calculator1 { //Calculator1 doSomethingComplex() method takes an integer input and returns cube of it public float doSomethingComplex(int x){ return x * x * x; } } package com.myjavablog.structural.facade; public class Calculator2 { //Calculator2 doAnotherThing() method takes an integer input and returns double of cube of it public float doAnotherThing(Calculator1 c1, int x){ return 2 * c1.doSomethingComplex(x); } } package com.myjavablog.structural.facade; public class Calculator3 { //Calculator3 doMoreStuff() method takes Calculator1 and Calculator2 objects and multiplies it public float doMoreStuff(Calculator1 c1, Calculator2 c2 , int x){ return c1.doSomethingComplex(x) * c2.doAnotherThing(c1, x) ; } } Facade.java – This class interacts with the base system of classes package com.myjavablog.structural.facade; /* This is the Facade class which interacts with this System of classes Names of the methods clearly indicates what they do This methods hides interactions of Calculator1,Calculator2,Calculator3 from client */ public class Facade { public float cubeX(int x){ Calculator1 c1 = new Calculator1(); return c1.doSomethingComplex(x); } public float cubeXTimes2(int x){ Calculator1 c1 = new Calculator1(); Calculator2 c2 = new Calculator2(); return c2.doAnotherThing(c1,x); } public float multiplyBoth(int x){ Calculator1 c1 = new Calculator1(); Calculator2 c2 = new Calculator2(); Calculator3 c3 = new Calculator3(); return c3.doMoreStuff(c1,c2,x); } } FacadePatternTest.java package com.myjavablog.structural.facade; import java.util.Scanner; //Client class public class FacadePatternTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println(“Enter the number:”); int x = sc.nextInt(); Facade facade = new Facade(); System.out.println(“Cube is “+facade.cubeX(x)); System.out.println(“Double of cube is “+facade.cubeXTimes2(x)); System.out.println(“Multiplication of both is “+facade.multiplyBoth(x)); } } Output: Enter the number: 9 Cube is 729.0 Double of cube is 1458.0 Multiplication of both is 1062882.0 Important Points: Facade pattern is more like a helper for client applications; it doesn’t hide subsystem interfaces from the client. Whether to use Facade or not is completely dependent on client code. Facade pattern can be applied at any point of development, usually when the number of interfaces grows and system gets complex. Subsystem interfaces are not aware of Facade and they shouldn’t have any reference of the Facade interface. Facade pattern should be applied for similar kind of interfaces; its purpose is to provide a single interface rather than multiple interfaces that does the similar kind of jobs. Subsystem may be dependent with one another. In such case, facade can act as a coordinator and decouple the dependencies between the subsystems. We can use factory design pattern with Facade to provide better interface to client systems. Usage in Java: In javax.faces.context, ExternalContext internally uses ServletContext, HttpSession, HttpServletRequest, HttpServletResponse, etc. It allows the Faces API to be unaware of the nature of its containing application environment.... Read more...PROXY PATTERNOctober 28, 2018design patternsThe Proxy Pattern provides a surrogate or placeholder for another object to control access to it. The Proxy Pattern is used to create a representative object that controls access to another object, which may be remote, expensive to create or in need of being secured. One reason for controlling access to an object is to defer the full cost of its creation and initialization until we actually need to use it. Another reason could be to act as a local representative for an object that lives in a different JVM. The Proxy can be very useful in controlling the access to the original object, especially when objects should have different access rights. In the Proxy Pattern, a client does not directly talk to the original object, it delegates it calls to the proxy object which calls the methods of the original object. The important point is that the client does not know about the proxy, the proxy acts as an original object for the client. But there are many variations to this approach which we will see soon. There are three main variations to the Proxy Pattern: A remote proxy provides a local representative for an object in a different address space. A virtual proxy creates expensive objects on demand. A protection proxy controls access to the original object. Protection proxies are useful when objects should have different access rights. IFolder.java package com.myjavablog.structural.proxy; public interface IFolder { public void performOperations(); } Folder.java package com.myjavablog.structural.proxy; public class Folder implements IFolder { @Override public void performOperations() { //Access folder and perform various operations like copy or cut System.out.println(“Performing operation on folder”); } } User.java package com.myjavablog.structural.proxy; public class User { String userName; String password; public User(String userName, String password) { this.userName = userName; this.password = password; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } } FolderProxy.java package com.myjavablog.structural.proxy; public class FolderProxy implements IFolder { Folder folder; User user; public FolderProxy(User user){ this.user = user; } @Override public void performOperations() { if(user.getUserName().equalsIgnoreCase(“test”) && user.getPassword().equalsIgnoreCase(“test”)){ folder=new Folder(); folder.performOperations(); }else{ System.out.println(“You don’t have access to this folder”); } } } ProxyPatternTest.java package com.myjavablog.structural.proxy; public class ProxyPatternTest { public static void main(String[] args) { User user = new User(“test”, “test”); FolderProxy folderProxy = new FolderProxy(user); System.out.println(“When username and password are correct”); folderProxy.performOperations(); System.out.println(“========================================”); User userWrong = new User(“abc”, “abc”); FolderProxy folderProxyWrong = new FolderProxy(userWrong); System.out.println(“When username and password are incorrect”); folderProxyWrong.performOperations(); } } Output: When username and password are correct Performing operation on folder ======================================== When username and password are incorrect You don’t have access to this folder When to use the Proxy Pattern: Proxy is applicable whenever there is a need for a more versatile or sophisticated reference to an object than a simple pointer. Here are several common situations in which the Proxy pattern is applicable: A remote proxy provides a local representative for an object in a different address space. A virtual proxy creates expensive objects on demand. A protection proxy controls access to the original object. Protection proxies are useful when objects should have different access rights. Proxy Pattern in JDK: The following cases are examples of usage of the Proxy Pattern in the JDK. java.lang.reflect.Proxy java.rmi. (whole package)... Read more...COMPOSITE PATTERNOctober 28, 2018design patternsThere are times when you feel a need of a tree data structure in your code. There are many variations to the tree data structure, but sometimes there is a need of a tree in which both branches as well as leafs of the tree should be treated as uniformly. The Composite Pattern allows you to compose objects into a tree structure to represent the part-whole hierarchy which means you can create a tree of objects that is made of different parts, but that can be treated as a whole one big thing. Composite lets clients to treat individual objects and compositions of objects uniformly, that’s the intent of the Composite Pattern. In the composite pattern, a tree structure exists where identical operations can be performed on leaves and nodes. A node in a tree is a class that can have children. A node class is a ‘composite’ class. A leaf in a tree is a ‘primitive’ class that does not have children. The children of a composite can be leaves or other composites. The leaf class and the composite class share a common ‘component’ interface that defines the common operations that can be performed on leaves and composites. When an operation on a composite is performed, this operation is performed on all children of the composite, whether they are leaves or composites. Thus, the composite pattern can be used to perform common operations on the objects that compose a tree. In Other words, Composite Pattern consists of following objects. Base Component – Base component is the interface for all objects in the composition, client program uses base component to work with the objects in the composition. It can be an interface or an abstract class with some methods common to all the objects. Leaf – Defines the behavior for the elements in the composition. It is the building block for the composition and implements base component. It doesn’t have references to other Components. Composite – It consists of leaf elements and implements the operations in base component. Example: Employee.java (Component) package com.myjavablog.structural.composite; /* First we will create component interface. It reresents objects in composition. It has all common operations applicable to both Manager and Developer. */ /* Employee – Component Developer – Leaf Manager – Composite */ public interface Employee { public void add(Employee e); public void remove(Employee e); public Employee getChild(int i); public String getName(); public double getSalary(); public void print(); } Manager.java (Composite) /* Manager is composite class. Key point here is all common methods delegates its operations to child objects It has methods to access and modify its children. */ package com.myjavablog.structural.composite; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Manager implements Employee { private String name; private double salary; List<Employee> employeeList = new ArrayList<>(); public Manager(String name, double salary) { this.name = name; this.salary = salary; } @Override public void add(Employee e) { employeeList.add(e); } @Override public void remove(Employee e) { employeeList.remove(e); } @Override public Employee getChild(int i) { return employeeList.get(i); } @Override public String getName() { return this.name; } @Override public double getSalary() { return this.salary; } @Override public void print() { System.out.println(“=======================================”); System.out.println(“Name = “+ this.getName()); System.out.println(“Salary = “+ this.getSalary()); System.out.println(“=======================================”); Iterator<Employee> employeeIterator = employeeList.iterator(); while(employeeIterator.hasNext()){ Employee emp = employeeIterator.next(); emp.print(); } } } Developer.java (Leaf) /* Developer is a leaf node so many methods are not applicable to this class */ package com.myjavablog.structural.composite; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Developer implements Employee { private String name; private double salary; public Developer(String name, double salary) { this.name = name; this.salary = salary; } @Override public void add(Employee e) { //This is a leaf node so this method is not applicable to this class } @Override public void remove(Employee e) { //This is a leaf node so this method is not applicable to this class } @Override public Employee getChild(int i) { //This is a leaf node so this method is not applicable to this class return null; } @Override public String getName() { return this.name; } @Override public double getSalary() { return this.salary; } @Override public void print() { System.out.println(“=======================================”); System.out.println(“Name = “+ this.getName()); System.out.println(“Salary = “+ this.getSalary()); System.out.println(“=======================================”); } } Runner class (CompositeTest.java ) package com.myjavablog.structural.composite; public class CompositeTest { public static void main(String[] args) { Employee e1 = new Developer(“Jack”, 87000); Employee e2 = new Developer(“Steve”, 97000); Employee manager1 = new Manager(“Bill”, 100000); manager1.add(e1); manager1.add(e2); Employee e3 = new Developer(“Daniel”, 50000); Manager gereralManager = new Manager(“Mark”, 80000); gereralManager.add(e3); gereralManager.add(manager1); gereralManager.print(); } } Output: ======================================= Name = Mark Salary = 80000.0 ======================================= ======================================= Name = Daniel Salary = 50000.0 ======================================= ======================================= Name = Bill Salary = 100000.0 ======================================= ======================================= Name = Jack Salary = 87000.0 ======================================= ======================================= Name = Steve Salary = 97000.0 =======================================... Read more...Structural Design PatternsOctober 25, 2018design patternsStructural Design Patterns: Structural patterns provide different ways to create a class structure, for example using inheritance and composition to create a large object from small objects. Following design patterns come under this category. Adapter Pattern Composite Pattern Proxy Pattern Flyweight Pattern Facade Pattern Bridge Pattern Decorator Pattern We will go through each of this type one by one in subsequent posts. Also code for all examples is available on GitHub on below link – DesignPattern Examples... Read more...ADAPTER PATTERNOctober 25, 2018design patternsSometimes, there could be a scenario when two objects don’t fit together, as they should in-order to get the work done. This situation could arise when we are trying to integrate a legacy code with a new code, or when changing a 3rd party API in the code. This is due to incompatible interfaces of the two objects which do not fit together. In other words, Adapter design pattern is one of the structural design patterns and it’s used so that two unrelated interfaces can work together. The object that joins these unrelated interfaces is called an Adapter. As a real life example, we can think of a mobile charger as an adapter because mobile battery needs 3 volts to charge but the normal socket produces either 120V (US) or 240V (India). So the mobile charger works as an adapter between mobile charging socket and the wall socket. In the adapter pattern, a wrapper class (i.e., the adapter) is used translate requests from it to another class (i.e., the adoptee). In effect, an adapter provides particular interactions with an adoptee that are not offered directly by the adoptee. The adapter pattern takes two forms. In the first form, a “class adapter” utilizes inheritance. The class adapter extends the adoptee class and adds the desired methods to the adapter. These methods can be declared in an interface (i.e., the “target” interface).In the second form; an “object adapter” utilizes composition. The object adapter contains an adoptee and implements the target interface to interact with the adoptee. Apple.java package com.myjavablog.structural.adapter; public class Apple { public void getAppleColor(String color){ System.out.println(“Apple color is “+ color); } } Orange.java package com.myjavablog.structural.adapter; public class Orange { public void getOrangeColor(String color){ System.out.println(“Orange color is “+ color); } } AppleAdapter.java adapter class – package com.myjavablog.structural.adapter; public class AppleAdapter extends Apple { //Purpose of sample problem is to orange as Apple private Orange orange; public AppleAdapter(Orange orange) { this.orange = orange; } public void getColor(String color){ orange.getOrangeColor(color); } } AdaterPatternTest.java class – package com.myjavablog.structural.adapter; public class AdaterPatternTest { public static void main(String[] args) { Apple apple1 = new Apple(); apple1.getAppleColor(“green”); Orange orange = new Orange(); AppleAdapter adapter = new AppleAdapter(orange); adapter.getAppleColor(“red”); } } Output: Apple color is green Apple color is red Orange is adoptee, apple is target & AppleAdapter is the adapter. Here idea is to pass adoptee in adapter’s constructor to achieve the goal. When to use Adapter Pattern: The Adapter pattern should be used when: There is an existing class, and its interface does not match the one you need. You want to create a reusable class that cooperates with unrelated or unforeseen classes, that is, classes that don’t necessarily have compatible interfaces. There are several existing subclasses to be use, but it’s impractical to adapt their interface by subclassing every one. An object adapter can adapt the interface of its parent class. Adapter Pattern Example in JDK: java.util.Arrays#asList() java.io.InputStreamReader(InputStream) (returns a Reader) java.io.OutputStreamWriter(OutputStream) (returns a Writer)... Read more...PROTOTYPE PATTERNOctober 25, 2018design patternsPrototype pattern is one of the Creational Design patterns, so it provides a mechanism of object creation. Prototype pattern is used when the Object creation is a costly affair and requires a lot of time and resources and you have a similar object already existing. So this pattern provides a mechanism to copy the original object to a new object and then modify it according to our needs. This pattern uses java cloning to copy the object. It would be easy to understand this pattern with an example, suppose we have an Object that loads data from database. Now we need to modify this data in our program multiple times, so it’s not a good idea to create the Object using new keyword and load all the data again from database. So the better approach is to clone the existing object into a new object and then do the data manipulation. Prototype design pattern mandates that the Object which you are copying should provide the copying feature. It should not be done by any other class. However whether to use shallow or deep copy of the Object properties depends on the requirements and it’s a design decision. One example of how this can be useful is if an original object is created with a resource such as a data stream that may not be available at the time that a clone of the object is needed. Another example is if the original object creation involves a significant time commitment, such as reading data from a database or over a network. Normally in Java, if you’d like to use cloning (i.e., the prototype pattern), you can utilize the clone () method and the Cloneable interface. By default, clone () performs a shallow copy. Serializable can be used to simplify deep copying. However, we can implement our own prototype pattern. To do so, we’ll create a Prototype interface that features a doClone () method. Below example describes how to design an advanced bike after cloning the basic bike object. package com.myjavablog.prototype; public class Bike implements Cloneable{ private int gears; private String bikeType; private String model; public Bike() { gears = 5; bikeType = “Standard”; model = “BMW”; } public Bike clone(){ return new Bike(); } public void makeAdvanced(){ gears = 5; bikeType = “Advanced”; model = “Jauguar”; } public int getGears() { return gears; } public String getBikeType() { return bikeType; } public String getModel() { return model; } @Override public String toString() { return “Bike{” + “gears=” + gears + “, bikeType='” + bikeType + ‘\” + “, model='” + model + ‘\” + ‘}’; } } Test class – package com.myjavablog.prototype; public class PrototypeTest { public Bike makeJaguar(Bike basicBike){ basicBike.makeAdvanced(); return basicBike; } public static void main(String[] args) { Bike bike = new Bike(); Bike basicBike = bike.clone(); PrototypeTest pt = new PrototypeTest(); Bike advancedBike = pt.makeJaguar(basicBike); System.out.println(“Advanced Bike model:”+ advancedBike.getModel()); System.out.println(“Advanced Bike :”+ advancedBike.toString()); } } Output: Advanced Bike model:Jauguar Advanced Bike :Bike{gears=5, bikeType=’Advanced’, model=’Jauguar’} When to Use: When the classes to instantiate are specified at run-time, for example, by dynamic loading. To avoid building a class hierarchy of factories that parallels the class hierarchy of products. When instances of a class can have one of only a few different combinations of state. It may be more convenient to install a corresponding number of prototypes and clone them rather than instantiating the class manually, each time with the appropriate state. Usage in JDK: java.lang.Object#clone ()... Read more...BUILDER PATTERNOctober 21, 2018design patternsIn general, the details of object construction, such as instantiating and initializing the components that make up the object, are kept within the object, often as part of its constructor. This type of design closely ties the object construction process with the components that make up the object. This approach is suitable as long as the object under construction is simple and the object construction process is definite and always produces the same representation of the object. However, this design may not be effective when the object being created is complex and the series of steps constituting the object creation process can be implemented in different ways, thus producing different representations of the object. Because the different implementations of the construction process are all kept within the object, the object can become bulky (construction bloat) and less modular. Subsequently, adding a new implementation or making changes to an existing implementation requires changes to the existing code. Using the Builder pattern, the process of constructing such an object can be designed more effectively. The Builder pattern suggests moving the construction logic out of the object class to a separate class referred to as a builder class. There can be more than one such builder classes, each with different implementations for the series of steps to construct the object. Each builder implementation results in a different representation of the object. The intent of the Builder Pattern is to separate the construction of a complex object from its representation, so that the same construction process can create different representations. This type of separation reduces the object size. The design turns out to be more modular with each implementation contained in a different builder object. Adding a new implementation (i.e., adding a new builder) becomes easier. The object construction process becomes independent of the components that make up the object. This provides more control over the object construction process. The Builder pattern suggests using a dedicated object referred to as a Director, which is responsible for invoking different builder methods required for the construction of the final object. Different client objects can make use of the Director object to create the required object. Once the object is constructed, the client object can directly request from the builder the fully constructed object. To facilitate this process, a new method getObject () can be declared in the common Builder interface to be implemented by different concrete builders. Builder Specifies an abstract interface for creating parts of a Product object. ConcreteBuilder Constructs and assembles parts of the product by implementing the Builder interface. Defines and keeps track of the representation it creates. Provides an interface for retrieving the product. Director Constructs an object using the Builder interface. Product Represents the complex object under construction. ConcreteBuilder builds the product’s internal representation and defines the process by which it’s assembled. Includes classes that define the constituent parts, including interfaces for assembling the parts into the final result. Steps for creating builder pattern in another way: Sometimes there is an object with a long list of properties, and most of these properties are optional. Consider an online form which needs to be filled in order to become a member of a site. You need to fill all the mandatory fields but you can skip the optional fields or sometimes it may look valuable to fill some of the optional fields. The question is, what sort of constructor should we write for such a class? Well writing a constructor with long list of parameters is not a good choice, this could frustrate the client especially if the important fields are only a few. This could increase the scope of error; the client may provide a value accidentally to a wrong field. Long sequences of identically typed parameters can cause subtle bugs. If the client accidentally reverses two such parameters, the compiler won’t complain, but the program will misbehave at runtime. Instead of making the desired object directly, the client calls a constructor with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameterless build method to generate the object. First of all you need to create a static nested class and then copy all the arguments from the outer class to the Builder class. We should follow the naming convention and if the class name is Cake then builder class should be named as CakeBuilder. The Builder class should have a public constructor with all the required attributes as parameters. Builder class should have methods to set the optional parameters and it should return the same Builder object after setting the optional attribute. The final step is to provide a build () method in the builder class that will return the Object needed by client program. For this we need to have a private constructor in the Class with Builder class as argument. Example: Cake.java package com.myjavablog.builder; public class Cake { private final double sugar; //measured by cup private final double butters; //measured by cup private final double milk; //measured by cup private final int cherry; //Private constructor to enforce object constructor through builder private Cake(CakeBuilder builder) { this.sugar = builder.sugar; this.butters = builder.butters; this.milk = builder.milk; this.cherry = builder.cherry; } public static class CakeBuilder { private double sugar; //measured by cup private double butters; //measured by cup private double milk; //measured by cup private int cherry; //Setting object properties public CakeBuilder sugar ( double cup){ this.sugar = cup; return this; } public CakeBuilder butters ( double cup){ this.butters = cup; return this; } public CakeBuilder milk ( double cup){ this.milk = cup; return this; } public CakeBuilder cherry ( int number){ this.cherry = number; return this; } //Return the object created public Cake build() { return new Cake(this); } } @Override public String toString() { return “Cake{” + “sugar=” + sugar + “, butters=” + butters + “, milk=” + milk + “, cherry=” + cherry + ‘}’; } } Testing builder pattern with TestBuilderPattern.java – package com.myjavablog.builder; public class TestBuilderPattern { public static void main(String[] args) { //Create object using builder pattern Cake chocolateCake = new Cake.CakeBuilder().sugar(1.5).butters(2).milk(6).cherry(3).build(); //Your choice of Cake is ready System.out.println(chocolateCake); } } Output: Cake{sugar=1.5, butters=2.0, milk=6.0, cherry=3} In static class setting property, we can use setter method as another option. As you can clearly see, now a client only needs to provide the mandatory fields and the fields which are important to him. To create the form object now, we need invoke the CakeBuilder constructor which takes the mandatory fields and then we need to call the set of required methods on it and finally the build method to get the form object. When to use the Builder Pattern: Use the Builder pattern when- The algorithm for creating a complex object should be independent of the parts that make up the object and how they’re assembled. The construction process must allow different representations for the object that’s constructed. Builder Pattern in JDK: java.lang.StringBuilder#append() (unsynchronized) java.lang.StringBuffer#append() (synchronized) java.nio.ByteBuffer#put() (also on CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer and DoubleBuffer) javax.swing.GroupLayout.Group#addComponent() All implementations of java.lang.Appendable. ... Read more...ABSTRACT FACTORY PATTERNOctober 21, 2018design patternsAlmost similar to except the fact that it’s more like factory of factories. If you are familiar with factory design pattern in java, you will notice that we have a single Factory class that returns the different sub-classes based on the input provided and factory class uses if-else or switch statement to achieve this. In Abstract Factory pattern, we get rid of if-else block and have a factory class for each sub-class and then an Abstract Factory class that will return the sub-class based on the input factory class. An abstract factory is a factory that returns factories. Why is this layer of abstraction useful? A normal factory can be used to create sets of related objects. An abstract factory returns factories. Thus, an abstract factory is used to return factories that can be used to create sets of related objects. As an example, you could have a Honda factory that returns car objects (Brio, Civic, etc.) associated with a Honda factory. You could also have a Hyundai factory that returns car objects (Santro, EON) associated with a Hyundai factory. We could create an abstract factory that returns these different types of car factories depending on the car that we were interested in. We could then obtain car objects from the car factories. Via polymorphism, we can use a common interface to get the different factories, and we could then use a common interface to get the different cars. Benefits: Abstract Factory pattern provides approach to code for interface rather than implementation. Abstract Factory pattern is “factory of factories” and can be easily extended to accommodate more products, for example we can add another sub-class Celerio and a factory MarutiFactory. Abstract Factory pattern is robust and avoid conditional logic of Factory pattern. When to use: A family of related product objects is designed to be used together, and you need to enforce this constraint. Example: ILaptopFactory.java interface package com.myjavablog.abstractfactory; public interface ILaptopFactory { public ILaptopFactory createLaptop(String type); } LaptopFactory.java class implementing factory interface – package com.myjavablog.abstractfactory; public class LaptopFactory implements ILaptopFactory{ @Override public ILaptopFactory createLaptop(String type) { ILaptopFactory laptop = null; if(“Lenovo”.equalsIgnoreCase(type)) laptop = new LenovoLaptopFactory(); else if(“dell”.equalsIgnoreCase(type)) laptop = new DellLaptopFactory(); return laptop; } } Then we create different factories for different laptop brands – LenovoLaptopFactory.java package com.myjavablog.abstractfactory; public class LenovoLaptopFactory extends LaptopFactory{ public Lenovo createLenovoLaptop() { return new Lenovo(); } } DellLaptopFactory.java package com.myjavablog.abstractfactory; public class DellLaptopFactory extends LaptopFactory{ public Dell createDellLaptop() { return new Dell(); } } Finally TestAbstractFactory.java to test abstract factory – package com.myjavablog.abstractfactory; public class TestAbstractFactory { public static void main(String[] args) { System.out.println(“Lenovo Configuration”); LaptopFactory factory = new LaptopFactory(); LenovoLaptopFactory llf = (LenovoLaptopFactory) factory.createLaptop(“lenovo”); Lenovo len = (Lenovo) llf.createLenovoLaptop(); len.processor(); len.cost(); System.out.println(“Dell Configuration”); DellLaptopFactory dlf = (DellLaptopFactory) factory.createLaptop(“dell”); Dell dell = (Dell) dlf.createDellLaptop(); dell.processor(); dell.cost(); } } Usage in JDK: javax.xml.parsers.DocumentBuilderFactory#newInstance() javax.xml.transform.TransformerFactory#newInstance() javax.xml.xpath.XPathFactory#newInstance()... Read more...FACTORY PATTERNOctober 20, 2018design patternsFactory design pattern is used when we have a super class with multiple sub-classes and based on input, we need to return one of the sub-classes. This pattern takes out the responsibility of instantiation of a class from client program to the factory class. We can apply Singleton pattern on Factory class or make the factory method static. Super class in factory pattern can be an interface or a normal java class. Benefits: Factory pattern provides approach to code for interface rather than implementation. Factory pattern removes the instantiation of actual implementation classes from client code, making it more robust, less coupled and easy to extend. For example, we can easily change PC class implementation because client program is unaware of this. Factory pattern provides abstraction between implementation and client classes through inheritance . Example: ILaptop.java interface package com.myjavablog.factory; public interface ILaptop { public void processor(); public void cost(); public void ramSize(); } Dell.java package com.myjavablog.factory; public class Dell implements ILaptop { @Override public void processor() { System.out.println(“Processor available in AMD, I3, I5, I7”); } @Override public void cost() { System.out.println(“Cost starts from 18k”); } @Override public void ramSize() { System.out.println(“RAM size starts from 1 GB”); } } Samsung.java package com.myjavablog.factory; public class Samsung implements ILaptop { @Override public void processor() { System.out.println(“Processor available in I3, I5, I7”); } @Override public void cost() { System.out.println(“Cost starts from 20k”); } @Override public void ramSize() { System.out.println(“RAM size starts from 2 GB”); } } Lenovo.java package com.myjavablog.factory; public class Lenovo implements ILaptop { @Override public void processor() { System.out.println(“Processor available in I3, I5”); } @Override public void cost() { System.out.println(“Cost starts from 25k”); } @Override public void ramSize() { System.out.println(“RAM size starts from 4 GB”); } } Now create a factory class LaptopFactory.java package com.myjavablog.factory; public class LaptopFactory { public ILaptop createLaptop(String type) { ILaptop laptop = null; if(“sam”.equalsIgnoreCase(type)){ laptop = new Samsung(); System.out.println(“Samsung laptop created”); }else if(“len”.equalsIgnoreCase(type)){ laptop = new Lenovo(); System.out.println(“Lenovo laptop created”); }if(“dell”.equalsIgnoreCase(type)){ laptop = new Dell(); System.out.println(“Dell laptop created”); } return laptop; } } Now create a main class to test Factory TestFactory.java– package com.myjavablog.factory; public class TestFactory { public static void main(String[] args) { LaptopFactory factory = new LaptopFactory(); Lenovo len = (Lenovo) factory.createLaptop(“len”); len.processor(); Dell dell = (Dell) factory.createLaptop(“dell”); dell.cost(); } } Output: Lenovo laptop created Processor available in I3, I5 Dell laptop created Cost starts from 18k Usage in JDK: java.util.Calendar, ResourceBundle and NumberFormat getInstance () methods uses Factory pattern. valueOf () method in wrapper classes like Boolean, Integer etc . ... Read more...SINGLETON PATTERNOctober 19, 2018design patternsSometimes it’s important for some classes to have exactly one instance. There are many objects we only need one instance of them and if we, instantiate more than one, we’ll run into all sorts of problems like incorrect program behavior, overuse of resources, or inconsistent results. There are only two points in the definition of a singleton design pattern, There should be only one instance allowed for a class We should allow global point of access to that single instance. From the definition, it seems to be a very simple design pattern but when it comes to implementation, it comes with a lot of implementation concerns. The implementation of Java Singleton pattern has always been a controversial topic among developers. Here we will learn about Singleton design pattern principles, different ways to implement Singleton design pattern and some of the best practices for its usage. Lazy initialization will be beneficial when we want to delay the initialization until it is not needed. because if we use eager initialization and if initialization fails there is no chance to get the instance further while in lazy initialization we may get it in second chance. In Lazy initialization we will not get instance until we call getInstance () method while in eager initialization it creates instance at the time of class loading. Below are some examples where Singleton pattern violation situation can be found. We will compare the hash code values of the objects to verify the similar objects. If hash code values of two objects are equal, those objects must be equal. 1. Reflection Using reflection we can set the private constructor to become accessible at runtime as shown in the example below. package com.myjavablog.singleton; import java.lang.reflect.Constructor; public class SingletonReflection { private static SingletonReflection instance = new SingletonReflection(); private static SingletonReflection getInstance() { return instance; } private SingletonReflection(){ System.out.println(“Creating Object…….”); } public static void print(String name, SingletonReflection obj){ System.out.println(“Object Name : “+ name +” Hashcode: “+ obj.hashCode()); } public static void main(String[] args) throws Exception { SingletonReflection sr1 = SingletonReflection.getInstance(); SingletonReflection sr2 = SingletonReflection.getInstance(); print(“S1”, sr1); print(“S2”, sr2); Class clazz = Class.forName(“com.myjavablog.singleton.SingletonReflection”); Constructor<SingletonReflection> constructor = clazz.getDeclaredConstructor(); constructor.setAccessible(true); SingletonReflection sr3 = constructor.newInstance(); print(“S3”, sr3); } } Output: Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Creating Object……. Object Name : S3 Hashcode: 1735600054 Fix for above problem: Throw Runtime Exception if someone tries to make instance in case one instance already exists. This code will go into the private constructor of the Singleton class. private SingletonReflection(){ if(instance!= null) throw new RuntimeException(“Can’t create an object . Use getIntance method to create the objects “); System.out.println(“Creating Object…….”); } Output post fix: Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Exception in thread “main” java.lang.reflect.InvocationTargetException at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at com.myjavablog.singleton.SingletonReflection.main(SingletonReflection.java:37) Caused by: java.lang.RuntimeException: Can’t create an object . Use getIntance method to create the objects at com.myjavablog.singleton.SingletonReflection.<init>(SingletonReflection.java:17) … 5 more 2.Cloning: If we try to make instance by cloning it, the generated hash code of cloned copy doesn’t match with the actual object so it also violates the Singleton principle. package com.myjavablog.singleton; import java.lang.reflect.Constructor; public class SingletonCloning implements Cloneable{ private static SingletonCloning instance = new SingletonCloning(); private static SingletonCloning getInstance() { return instance; } private SingletonCloning() { System.out.println(“Creating Object…….”); } @Override protected Object clone() throws CloneNotSupportedException { //if(instance!= null) // throw new CloneNotSupportedException(“Cant clone singleton objects”); return super.clone(); } public static void print(String name, SingletonCloning obj){ System.out.println(“Object Name : “+ name +” Hashcode: “+ obj.hashCode()); } public static void main(String[] args) throws Exception { SingletonCloning sr1 = SingletonCloning.getInstance(); SingletonCloning sr2 = SingletonCloning.getInstance(); print(“S1”, sr1); print(“S2”, sr2); SingletonCloning sr3 = (SingletonCloning) sr2.clone(); print(“S3”, sr3); } } Output: Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Object Name : S3 Hashcode: 1735600054 Fix for above issue: Throw CloneNotSupportedException from the clone () method if someone tries to make other instance of it. Uncomment the commented line from clone () method. @Override protected Object clone() throws CloneNotSupportedException { if(instance!= null) throw new CloneNotSupportedException(“Cant clone singleton objects”); return super.clone(); } Post fix Ouput : Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Exception in thread “main” java.lang.CloneNotSupportedException: Cant clone singleton objects at com.myjavablog.singleton.SingletonCloning.clone(SingletonCloning.java:22) at com.myjavablog.singleton.SingletonCloning.main(SingletonCloning.java:39) 3. Serialization/Deserialization: When we serialize an object and deserialize it again there are different hash code values generated as shown in the example below. So our Singleton principle breaks in case of object serialization/deserialization. package com.myjavablog.singleton; import java.io.*; public class SingletonSerialize implements Serializable { private static SingletonSerialize instance = new SingletonSerialize(); private static SingletonSerialize getInstance() { return instance; } private SingletonSerialize() { System.out.println(“Creating Object…….”); } public static void print(String name, SingletonSerialize obj){ System.out.println(“Object Name : “+ name +” Hashcode: “+ obj.hashCode()); } public static void main(String[] args) throws Exception { SingletonSerialize sr1 = SingletonSerialize.getInstance(); SingletonSerialize sr2 = SingletonSerialize.getInstance(); print(“S1”, sr1); print(“S2”, sr2); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“C:\\Users\\anupb\\IdeaProjects\\DesignPatterns\\tmp\\s2.ser”)); oos.writeObject(sr2); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“C:\\Users\\anupb\\IdeaProjects\\DesignPatterns\\tmp\\s2.ser”)); SingletonSerialize sr3 = (SingletonSerialize) ois.readObject(); print(“S3”, sr3); } } Output: Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Object Name : S3 Hashcode: 2074407503 Fix for above issue: Implement readResolve () method in the Singleton class as shown below private Object readResolve(){ System.out.println(“Applying read Resolve …….”); return instance; } Post fix output: Creating Object……. Object Name : S1 Hashcode: 356573597 Object Name : S2 Hashcode: 356573597 Applying read Resolve ……. Object Name : S3 Hashcode: 356573597 4. Multithreaded: Singleton will work properly in multithreaded environment only if eager instantiation has been done because in this case instance creation will happen at the time of class loading only. But for Lazy instantiation we will have to take care of multiple things. If we want to delay the instantiation because of cost, we use to go with lazy. Following code demonstrates the behavior of Singleton instance when two threads are getting executed by comparing their hash code values. Be careful while running the following code as it will work only in Java 8 and later versions. package com.myjavablog.singleton; import java.io.Serializable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SingletonThread implements Serializable { //Lazy initialization private static SingletonThread instance = null; private static SingletonThread getInstance() { if(instance == null) instance = new SingletonThread(); return instance; } private SingletonThread() { System.out.println(“Creating Object…….”); } public static void print(String name, SingletonThread obj){ System.out.println(“Object Name : “+ name +” Hashcode: “+ obj.hashCode()); } static void useSingleton(){ SingletonThread singletonThread = SingletonThread.getInstance(); print(“singletonThread”, singletonThread); } public static void main(String[] args) throws Exception { ExecutorService service = Executors.newFixedThreadPool(2); service.submit(SingletonThread::useSingleton); service.submit(SingletonThread::useSingleton); service.shutdown(); } } Output: Creating Object……. Object Name : singletonThread Hashcode: 722702912 Object Name : singletonThread Hashcode: 722702912 Creating Object……. Creating Object……. Object Name : singletonThread Hashcode: 1588147852 Object Name : singletonThread Hashcode: 1059951119 When you run the above program many times you will notice that in multithreaded environment sometimes Singleton principle works but sometimes it violates. Therefore we need to synchronize the getInstance () method as shown below – private static synchronized SingletonThread getInstance() { if(instance == null) instance = new SingletonThread(); return instance; } After applying synchronize keyword in the getInstance () method the program will execute properly without any issue but in Java instead of synchronizing whole method we can synchronize only the block of code which is affected while creating instance to escape the extra overhead as below – private static SingletonThread getInstance() { if(instance == null) { // Check 1 synchronized (SingletonThread.class) { if(instance == null) {// Check 2 instance = new SingletonThread(); } } } return instance; } From the above code we have narrowed down the scope of synchronization for performance reasons. Notice that if a thread at line # 3 sees that instance is null and then it gets the lock of object at line # 5. At the same time if another thread already has the lock it will create the instance. So to make sure no other thread has already acquired the lock we will apply one more check after acquiring the lock as shown below. This method is called Double Checked Locking. Sometimes double checked locking also breaks the Principle of Singleton. Java runtime publishes half initialized variable. Suppose 2 threads thread1 & thread2 are entering into the code it goes through the line #3 to line #6 and created the instance. At the same time thread 2 enters and it knows that there is something in variable named as ‘instance’ (since it is at half initialized state) and it returns the same from line #10. Therefore Singleton principle breaks. To address this situation use volatile keyword at the time of instance declaration. Value of volatile variable will be published only when the change completes. Change to write operation happens before read operation in volatile variable. In short all threads will see the same value of variable. private static SingletonThread instance = null; 5. Enum Singleton: Joshua Bloch suggests the use of Enum to implement Singleton design pattern as Java ensures that any enum value is instantiated only once in a Java program. Since Java Enum values are globally accessible, so is the singleton. The drawback is that the enum type is somewhat inflexible; for example, it does not allow lazy initialization. package com.myjavablog.singleton; public enum SingletonEnum { private static SingletonEnum instance = null; private static void doSomething() { //do Something } } Enum Singleton doesn’t violate principle of Singleton in any case described above. Some Real time Examples of Singleton Design Pattern – Logger – You use Singleton pattern for the Logger class. In case it is not Singleton, every client will have its own Logger object and there will be concurrent access on the Logger instance in Multithreaded environment, and multiple clients will create/write to the Log file concurrently, this leads to data corruption. Loading Configuration file in Web Application Consider the situation of AudioDriverService which is designed in Singleton Pattern. So we are allowed to create just a single instance of AudioDriverService class. Now actually your Windows Media Player or Youtube Player both will share the same object of AudioDriverService rather than creating a new instance. Database connections... Read more...Creational Design PatternsOctober 19, 2018design patternsCreational design patterns provide solution to instantiate an object in the best possible way for specific situations. Following design patterns come under this category – Singleton Pattern Factory Pattern Abstract Factory Pattern Builder Pattern Prototype Pattern We will go through each of this type one by one in subsequent posts. Also code for all examples is available on GitHub on below link – DesignPattern Examples... Read more...SerializationSeptember 16, 2018Interview1. What is the serialization? Serialization is a process converting an object into a byte array. This byte array represents the class, version and internal state of the object. JVM can use this byte array to transmit/read the object over a network. 2. What is the purpose of serialization? Some of the uses of serialization are: Communication: It is used for transmitting an object over network between two machines. Persistence: We can store the object’s state in a database and retrieve it from database later on. Caching: Serialization can be used for caching to improve performance. We may need 10 minutes to build an object, but it may take just 10 seconds to de-serialize the object. Cross JVM Synchronization: It can be used in same way across multiple JVM that follow different architecture. 3. What is Deserialization? Deserialization is the process of reconstructing the object from the serialized state. It is the reverse process of serialization. 4. What is Serialization and Deserialization conceptually? Serialization is to convert Object data into a stream of bytes. Deserialization is to convert a stream of bytes back into a copy of the original object. 5. Why do we mark a data member transient? Member variables of an object are marked transient to indicate that they should not be serialized. During serialization process the transient variables are not considered part of the persistent state of an object. 6. Is it allowed to mark a method as transient? No, Java does not allow marking a method as transient. The transient keyword is valid only for member variables. 7. How does marking a field as transient makes it possible to serialize an object? Let say we have a class ABC that implements Serializable interface, but it contains a member variable object of class XYZ that does not implement Serializable interface. Due to this it is not possible to Serialize the class ABC. To solve this issue, we can mark the member variable XYZ as Transient in class ABC. This will allow us to serialize the class ABC. 8. What is Externalizable interface in Java? Externalizable interface extends Serializable interface in Java. It is used for giving the Class control over saving and restoring the contents of its instances. A class implements methods writeExternal() and readExternal() to store and restore the object. 9. What is the difference between Serializable and Externalizable interface? Serializable is a marker interface but Externalizable is not a marker interface. When we implement Serializable interface, the class is serialized automatically by default. We can override writeObject() and readObject()methods to control more complex object Serialization process. In case of Externalizable, we use readExternal() and writeExternal() methods to give control to class for class’s serialization process. Serializable interface is based on recursive algorithm. Serializable gives you two options. One option is to provide custom way of serialization, the other default way. In Externalizable, you have to always implement readExternal() and writeExternal() methods. A public no-arg constructor is needed while using Externalizable interface. In Serialization, we need to define serialVersionUID. If it is not explicitly defined it will be generated automatically based on all the fields, methods of the class. ... Read more...InternationalizationSeptember 16, 2018Interview1. What is Locale in Java? A Locale object represents a specific geographical, political, or cultural region. It is used to locale-sensitive operations in Java. It helps is following the local conventions of a country, native or region. These conventions can be for formatting the dates, money, numbers etc. 2. How will you use a specific Locale in Java? To use a specific Locale, we need to load that Locale. We can use ResourceBundle.getBundle(“Locale.UK”) method to load a Locale. ... Read more...PackagesSeptember 15, 2018Interview1. What is the purpose of package in Java? A package is used to encapsulate a group of classes, interfaces and sub-packages. Often, it is a hierarchical structure of storing information. It is easier to organize the related classes and subpackages in this manner. A Package also provides access protection for classes and interfaces. A package also helps in removing naming collision. 2. What is java.lang package? In Java, java.lang package contains the classes that are fundamental to the design of Java programming language. The most important class in this package is Object class. It also contains wrapper classes like- Integer, Boolean, Character etc. It provides Math class for mathematical operations. 3. Which is the most important class in Java? It is an open-ended question with many answers. In my view, Object class is the most important class of Java programming language. It is the root of all the classes in Java. It provides some very important and fundamental methods. 4. Is it mandatory to import java.lang package every time? No. By default, JVM loads it internally. 5. Can you import same package or class twice in your class? If we import same package multiple times in a class, compiler includes it only once. So neither JVM nor Compiler gives any error/warning on including a package multiple times. If you have two classes with same name, then you may get name collision on importing the class erroneously. JVM internally loads the class only one time. 6. What is a static import in Java? Static import is similar to normal import declaration. Normal import allows us to import classes from packages without using package qualifier. Static import allows us to import static members from a class without using class qualifier. 7. What is the difference between import static com.test.Fooclass and import com.test.Fooclass? First import is a static import and the second import is normal import of a class. First import allows us to import static members of class. ... Read more...StaticSeptember 15, 2018Interview1. In Java, why do we use static variable? Whenever we want to have a common property for all objects of a class, we use a class level variable i.e. a static variable. This variable is loaded in memory only once at the time of class loading. So it saves memory, since it is not defined per object in Java. 2. Why it is not a good practice to create static variables in Java? Static variables are common to all the objects of a class. If a new object is created, there is no need to test the value of static variable. Any code that uses static variable can be in any state. It can be within a new object or at a class level. So the scope of static variable is open ended in a Java class. If we want tighter control on scope, then variables should be created at the object creation level. Also defining static variables is not a good practice because they go against the principles of Object Oriented Programming. 3. What is the purpose of static method in Java? Java provides the feature of static method to create behavior at the class level. The static method is common to all the objects of a class. We do not need to create any object of a class to call a static method. So it provides convenience of not creating an object for calling it. Also a static method can access and modify static data members. This also helps in keeping the behavior as well as state at the class level. 4. Why do we mark main method as static in Java? The main method in Java is marked as static, so that JVM can call it to start the program. If main method is not static, then which constructor will be called by Java process? As such it is a known as convention to mark main method static in Java. But if we remove the static, then there will be ambiguity. Java process may not know which method of a class to call to start the program. So this convention helps in Java process to identify the starting code for a program in class that is passed as an argument to java process. 5. In what scenario do we use a static block? At times, there is a class that has static member variables. These variables need some complicated initialization. At this time static block helps as a tool to initialize complex static member variable initialization. The static block is executed even before the execution of main.Sometimes, we can also replace static block with a static method of class. 6. Is it possible to execute a program without defining a main() method? No, with Java 7 onwards, you need a main() method to execute a program. In earlier versions of Java, there was a workaround available to use static blocks for execution. But now this gap has been closed. 7. What happens when static modifier is not mentioned in the signature of main method? As per Java specification, main method has to be marked as static. It needs only one argument that is an array of String. A program can compile with a non-static method. But on execution it will give NoSuchMethodError. 8. What is the difference between static method and instance method in Java? Often, there is a need to define a behavior for a class that is not dependent on member variables of an object. Such behavior is captured in a static method. If there is a behavior dependent upon the member variables of an object, then we do not mark it static, it remains as instance method. To call as static method, we do not need to create an object. We just call it with class name. But to call an instance method, we need to create/get an object first. Instance member variables cannot be accessed by a static method. But an instance method can call both instance variables and static variables.... Read more...FinalSeptember 15, 2018Interview1. How can you change the value of a final variable in Java? Java does not allow changing the value of a final variable. Once the value is set, it cannot be changed. 2. Can a class be marked final in Java? Yes a class can be marked final in Java. Once a class is marked final, it cannot be extended. 3. How can we create a final method in Java? To mark a method, add modifier final to that method. A final method can not be overridden by a child class. 4. How can we prohibit inheritance in Java? If you mark a class final, it cannot be extended. This will prohibit the inheritance of that class in Java. 5. Why Integer class in final in Java? Integer class is a wrapper for int. If it is not marked final, then any other class can extend it and modify the behavior of Integer operations. To avoid this Integer wrapper class is marked as final. 6. What is a blank final variable in Java? When we declare a final variable without giving any initial value, then it is called blank final variable. 7. How can we initialize a blank final variable? A blank final instance variable can be initialized in a constructor.A blank final static variable can be initialized in the static block of class. 8. Is it allowed to declare main method as final? Yes, we can mark the main method as final. ... Read more...Collections Interview questionsSeptember 11, 2018Core Java1. What can cause java.util.concurrentmodificationexception ? The ConcurrentModificationException is a RuntimeException that may be thrown by methods that have detected concurrent modification of an object, when such modification is not permissible. An example of not permissible behavior is when a thread tries to modify the internal structure of a Collection, while another thread is iterating over it. The results of the iteration are undefined. Some iterators throw a ConcurrentModificationException when they detect such behavior. These iterators are called fail-fast iterators, as they stop the normal execution and report an error, rather than continuing in a non-deterministic way. Notice that this exception does not indicate that the object has been concurrently modified by a different thread. There could be below cases which can cause ConcurrentModificationException – Case 1: Collection is modified internally while iterating over it /** ConcurrentModification Exception Case1 example * */ package com.myjavablog.javainterview.concurrentmodificationexception; import java.util.HashMap; import java.util.Map; public class CMException_Case1 { public static void main(String[] args) { Map<String, Integer> map = new HashMap<String, Integer>(); // Insert some sample key-value pairs. map.put(“KEY1”, 10); map.put(“KEY2”, 20); map.put(“KEY3”, 30); /* Remove a value of the map, while iterating over it. * The following code throws a java.util.ConcurrentModificationException. */ for(String key: map.keySet()) { if(map.get(key) == 10) map.remove(key); } System.out.println(“Successfully removed a pair!”); } } Output: Exception in thread “main” java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437) at java.util.HashMap$KeyIterator.next(HashMap.java:1461) at com.myjavablog.javainterview.concurrentmodificationexception.CMException_Case1.main(CMException_Case1.java:22) This exception came because we removed the element from HashMap while iterating through it. Case 2: After the creation of an iterator, the Collection is internally modified by any method other than the iterator’s own methods for removal and addition. /** ConcurrentModification Exception Case2 example * */ package com.myjavablog.javainterview.concurrentmodificationexception; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class CMException_Case2 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); // Insert some sample values. list.add(“VALUE1”); list.add(“VALUE2”); list.add(“VALUE3”); // Get an iterator. Iterator<String> ite = list.iterator(); /* * Remove the first object of the list. This statement will force the iterator * to throw a ConcurrentModificationException. */ list.remove(0); while (ite.hasNext()) System.out.println(ite.next()); } } Output: Exception in thread “main” java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437) at java.util.HashMap$KeyIterator.next(HashMap.java:1461) at com.myjavablog.javainterview.concurrentmodificationexception.CMException_Case1.main(CMException_Case1.java:22) This exception came because we removed the element from list rather than using iterator’s own remove method. Case 3: Two iterators simultaneously modify the internal structure of a Collection. /** ConcurrentModification Exception Case3 example * */ package com.myjavablog.javainterview.concurrentmodificationexception; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class CMException_Case3 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); // Insert some sample values. list.add(“VALUE1”); list.add(“VALUE2”); list.add(“VALUE3”); // Get two iterators. Iterator<String> ite = list.iterator(); Iterator<String> ite2 = list.iterator(); // Point to the first object of the list and then, remove it. ite.next(); ite.remove(); /* The second iterator tries to remove the first object as well. The object does * not exist and thus, a ConcurrentModificationException is thrown. */ ite2.next(); ite2.remove();} } Output: Exception in thread “main” java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437) at java.util.HashMap$KeyIterator.next(HashMap.java:1461) at com.myjavablog.javainterview.concurrentmodificationexception.CMException_Case1.main(CMException_Case1.java:22) This exception came because , 1st iterator modifies the internal structure of the list, by removing its first object. The 2nd iterator tries to remove the first object as well, but the first object does not exist and thus, a ConcurrentModificationException is thrown. 2. How to get rid of ConcurrentModificationException collections ? Synchronization In order to avoid more than one threads accessing or modifying the same object, you can synchronize them over the object, in order to allow only one thread to manipulate it over the time. However, notice that this approach may reduce the performance of your application, or create deadlocks, if the application has not been developed carefully. Synchronized Collections In addition to their default implementations, Java provides a synchronized implementation of a Map, a List, a Set, a Collection, etc. through the Collections class. Moreover, Java provides the CopyOnWriteArrayList class, in which all mutative operations are implemented by making a fresh copy of the underlying array. Finally, Java also provides the ConcurrentHashMap class, which offers full concurrency of retrievals and adjustable expected concurrency for updates. All referenced implementations are thread safe. However, the usage of such data structures may also reduce the performance of your application, as thread synchronization spends CPU cycles. Iterator’s remove method In a single-threaded environment, use the iterator’s remove method, in order to concurrently iterate over a collection and remove things from it. Example: /** How to avoid ConcurrentModification Exception * */ package com.myjavablog.javainterview.concurrentmodificationexception; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class CMException_Solution { public static void main(String[] args) { List<String> list = new ArrayList<String>(); // Insert some sample values. list.add(“VALUE1”); list.add(“VALUE2”); list.add(“VALUE3”); // Get iterator. Iterator<String> ite = list.iterator(); while(ite.hasNext()) { String value = ite.next(); if(value.equals(“VALUE1”) ) ite.remove(); else System.out.println(value); } } } 3. What do you understand by iterator fail-fast property? Iterator fail-fast property checks for any modification in the structure of the underlying collection everytime we try to get the next element. If there are any modifications found, it throws ConcurrentModificationException. All the implementations of Iterator in Collection classes are fail-fast by design except the concurrent collection classes like ConcurrentHashMap and CopyOnWriteArrayList. 4. What is difference between fail-fast and fail-safe? Iterator fail-safe property work with the clone of underlying collection, hence it’s not affected by any modification in the collection. By design, all the collection classes in java.util package are fail-fast whereas collection classes in java.util.concurrent are fail-safe. Fail-fast iterators throw ConcurrentModificationException whereas fail-safe iterator never throws ConcurrentModificationException. 5. How to avoid ConcurrentModificationException while iterating a collection? We can use concurrent collection classes to avoid ConcurrentModificationException while iterating over a collection, Example CopyOnWriteArrayList instead of ArrayList, ConcurrentHashMap instead of HashMap. 6. What is the importance of hashCode() and equals() methods? HashCode and Equals methods in java 7. What is the output for below program? package com.myjavablog.javainterview.collections; import java.util.HashSet; class City { private String name; City(String name) { this.name = name; } public String toString() { return name; } } public class CollectionQuiz1 { public static void main(String[] str) { HashSet myMap = new HashSet(); String s1 = new String(“Mumbai”); String s2 = new String(“Mumbai”); City s3 = new City(“Pune”); City s4 = new City(“Pune”); myMap.add(s1); myMap.add(s2); myMap.add(s3); myMap.add(s4); System.out.println(myMap); } } Output: Explaination: As string class has hashcode() and equals() methods overridden in it, s1 and s2 object has same hashcode and equals method will also return true so duplicate string will be discarded . But in case of custom City objects , we don’t have hashcode() and equals() methods implemented in it. So two city objects are pointing to different memory addresses and thus considered different and will be inserted into Set. Please refer for more information – HashCode and Equals methods in java 8. What is the output for below program? package com.myjavablog.javainterview.collections; import java.util.HashSet; public class Student { public String name; @Override public int hashCode() { return 27; } @Override public boolean equals(Object obj) { return true; } public static void main(String args[]) { Student StudentOne = new Student(); Student StudentTwo = new Student(); Student StudentThree = new Student(); StudentOne.name = “John”; StudentTwo.name = “Darren”; StudentThree.name = “Simon”; HashSet StudentSet = new HashSet(); StudentSet.add(StudentOne); StudentSet.add(StudentTwo); StudentSet.add(StudentThree); System.out.println(StudentSet.size()); } } Output: 1 Explaination: Here hashcode() method always return same hashcode i.e. 27 and equals() always return true. This means ,we can not differentiate between these objects and all are considered same. So we will have only one object at the end even if we add as many objects in Set. Please refer for more information – HashCode and Equals methods in java 7. Can we add elements to collections if it is declared as final? Question arises to our mind whether we can add elements to collection defined as final. As we can’t modify the variable defined as final. Lets see below example – /** Adding elements to final Collection * */ package com.myjavablog.javainterview.concurrentmodificationexception; import java.util.ArrayList; import java.util.List; public class FinalCollection { public static void main(String[] args) { final List<String> list = new ArrayList<>(); list.add(“Test1”); list.add(“Test2”); list.add(“Test3”); list.add(“Test4”); System.out.println(list); } // We try to add list1 reference to final list List<String> list1 = new ArrayList<>(); list1.add(“Test5”); list1.add(“Test6”); list = list1; } Output: First sysout will print below – When we try to add list1 reference to final list below compile time exception will be shown – The final local variable list cannot be assigned. It must be blank and not using a compound assignment 8. What is difference between HashMap and Hashtable? HashMap and Hashtable both implements Map interface and looks similar, however there are following difference between HashMap and Hashtable. HashMap allows null key and values whereas Hashtable doesn’t allow null key and values. Hashtable is synchronized but HashMap is not synchronized. So HashMap is better for single threaded environment, Hashtable is suitable for multi-threaded environment. LinkedHashMap was introduced in Java 1.4 as a subclass of HashMap, so incase you want iteration order, you can easily switch from HashMap to LinkedHashMap but that is not the case with Hashtable whose iteration order is unpredictable. HashMap provides Set of keys to iterate and hence it’s fail-fast but Hashtable provides Enumeration of keys that doesn’t support this feature. Hashtable is considered to be legacy class and if you are looking for modifications of Map while iterating, you should use ConcurrentHashMap. 9. How to decide between HashMap and TreeMap? For inserting, deleting, and locating elements in a Map, the HashMap offers the best alternative. If, however, you need to traverse the keys in a sorted order, then TreeMap is your better alternative. Depending upon the size of your collection, it may be faster to add elements to a HashMap, then convert the map to a TreeMap for sorted key traversal. 10. What is difference between ArrayList and LinkedList? ArrayList and LinkedList both implement List interface but there are some differences between them. ArrayList is an index based data structure backed by Array, so it provides random access to it’s elements with performance as O(1) but LinkedList stores data as list of nodes where every node is linked to it’s previous and next node. So even though there is a method to get the element using index, internally it traverse from start to reach at the index node and then return the element, so performance is O(n) that is slower than ArrayList. Insertion, addition or removal of an element is faster in LinkedList compared to ArrayList because there is no concept of resizing array or updating index when element is added in middle. LinkedList consumes more memory than ArrayList because every node in LinkedList stores reference of previous and next elements. 11. What are concurrent Collection Classes? Java 1.5 Concurrent package (java.util.concurrent) contains thread-safe collection classes that allow collections to be modified while iterating. By design Iterator implementation in java.utilpackages are fail-fast and throws ConcurrentModificationException. But Iterator implementation in java.util.concurrent packages are fail-safe and we can modify the collection while iterating. Some of these classes are CopyOnWriteArrayList, ConcurrentHashMap, CopyOnWriteArraySet. 12. What is BlockingQueue? java.util.concurrent.BlockingQueue is a Queue that supports operations that wait for the queue to become non-empty when retrieving and removing an element, and wait for space to become available in the queue when adding an element. BlockingQueue interface is part of java collections framework and it’s primarily used for implementing producer consumer problem. We don’t need to worry about waiting for the space to be available for producer or object to be available for consumer in BlockingQueue as it’s handled by implementation classes of BlockingQueue. Java provides several BlockingQueue implementations such as ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue etc. 13. What is Collections Class? java.util.Collections is a utility class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, “wrappers”, which return a new collection backed by a specified collection, and a few other odds and ends. This class contains methods for collection framework algorithms, such as binary search, sorting, shuffling, reverse etc. 14. What is Comparable and Comparator interface? Java provides Comparable interface which should be implemented by any custom class if we want to use Arrays or Collections sorting methods. Comparable interface has compareTo(T obj) method which is used by sorting methods. We should override this method in such a way that it returns a negative integer, zero, or a positive integer if “this” object is less than, equal to, or greater than the object passed as argument. But, in most real life scenarios, we want sorting based on different parameters. For example, I would like to sort the employees based on Salary as well as age. This is the situation where we need to use Comparator interface because Comparable.compareTo(Object o) method implementation can sort based on one field only and we can’t chose the field on which we want to sort the Object. Comparator interface compare(Object o1, Object o2) method need to be implemented that takes two Object argument, it should be implemented in such a way that it returns negative int if first argument is less than the second one and returns zero if they are equal and positive int if first argument is greater than second one. 15. What is difference between Comparable and Comparator interface? Comparable and Comparator interfaces are used to sort collection or array of objects. Comparable interface is used to provide the natural sorting of objects and we can use it to provide sorting based on single logic. Comparator interface is used to provide different algorithms for sorting and we can chose the comparator we want to use to sort the given collection of objects. 16. While passing a Collection as argument to a function, how can we make sure the function will not be able to modify it? We can create a read-only collection using Collections.unmodifiableCollection(Collection c)method before passing it as argument, this will make sure that any operation to change the collection will throw UnsupportedOperationException. 17. How can we create a synchronized collection from given collection? We can use Collections.synchronizedCollection(Collection c) to get a synchronized (thread-safe) collection backed by the specified collection. 18. How can we sort a list of Objects? If we need to sort an array of Objects, we can use Arrays.sort(). If we need to sort a list of objects, we can use Collections.sort(). Both these classes have overloaded sort() methods for natural sorting (using Comparable) or sorting based on criteria (using Comparator). Collections internally uses Arrays sorting method, so both of them have same performance except that Collections take sometime to convert list to array. 19. Which collection classes are thread-safe? Vector, Hashtable, Properties and Stack are synchronized classes, so they are thread-safe and can be used in multi-threaded environment. Java 1.5 Concurrent API included some collection classes that allows modification of collection while iteration because they work on the clone of the collection, so they are safe to use in multi-threaded environment. 20. Which collection classes provide random access of it’s elements? ArrayList, HashMap, TreeMap, Hashtable classes provide random access to it’s elements. 21. How HashMap works in Java?... Read more...Immutable Class in JavaSeptember 10, 2018InterviewHere i am going to share some questions on Immutable classes in java – 1. What is an immutable class? Immutable class is a class which once created, it’s contents can not be changed. It means any modification on immutable object will result in a new immutable object. Immutable objects are particularly useful in concurrent applications. Since they cannot change state, they cannot be corrupted by thread interference or observed in an inconsistent state. Example: String , Integer , Float etc. 2. How can you create custom immutable class in java? Declare all instance variables private and final : If you make instance variable private, no outside class will be able to access instance variables and if you make them final, you can not change it. Don’t provide setter methods : Don’t create setter method for any instance variables, hence there will be no explicit way to change state of instance variables. Initialize all variables in constructor : You can initialize variables in constructor. You need to take special care while working with mutable object. You need to do deep copy in case of immutable objects. Make your class final : If you make your class final, no class will be able to extend it, hence will not be able override methods of this class. Clone mutable objects while returning from getter method: If you return clone of object from getter method, it won’t return original object, so your original object will remain intact. If the getters return an Object reference such as Collections, Arrays or other class object, clone the object before returning. Make sure the object is deep clone and not shallow. FinalClassDemo.java /** Mutable class example * */ package com.myjavablog.javainterview; import java.util.HashMap; import java.util.Iterator; public final class FinalClassDemo { private final int id; private final String name; private final HashMap<String, String> testMap; public int getId() { return id; } public String getName() { return name; } /** * Accessor function for mutable objects */ public HashMap<String, String> getTestMap() { // return testMap; return (HashMap<String, String>) testMap.clone(); } /** * Constructor performing Deep Copy * * @param i * @param n * @param hm */ public FinalClassDemo(int i, String n, HashMap<String, String> hm) { System.out.println(“Performing Deep Copy for Object initialization”); this.id = i; this.name = n; HashMap<String, String> tempMap = new HashMap<String, String>(); String key; Iterator<String> it = hm.keySet().iterator(); while (it.hasNext()) { key = it.next(); tempMap.put(key, hm.get(key)); } this.testMap = tempMap; } /** * Constructor performing Shallow Copy * * @param i * @param n * @param hm */ /** * public FinalClassDemo(int i, String n, HashMap<String,String> hm){ * System.out.println(“Performing Shallow Copy for Object initialization”); * this.id=i; this.name=n; this.testMap=hm; } */ /** * To test the consequences of Shallow Copy and how to avoid it with Deep Copy * for creating immutable classes * * @param args */ public static void main(String[] args) { HashMap<String, String> h1 = new HashMap<String, String>(); h1.put(“1”, “Final1”); h1.put(“2”, “Final2”); String s = “original”; int i = 10; FinalClassDemo ce = new FinalClassDemo(i, s, h1); // Lets see whether its copy by field or reference System.out.println(s == ce.getName()); System.out.println(h1 == ce.getTestMap()); // print the ce values System.out.println(“ce id:” + ce.getId()); System.out.println(“ce name:” + ce.getName()); System.out.println(“ce testMap:” + ce.getTestMap()); // change the local variable values i = 20; s = “modified”; h1.put(“3”, “Final3”); // print the values again System.out.println(“ce id after local variable change:” + ce.getId()); System.out.println(“ce name after local variable change:” + ce.getName()); System.out.println(“ce testMap after local variable change:” + ce.getTestMap()); HashMap<String, String> hmTest = ce.getTestMap(); hmTest.put(“4”, “Final4”); System.out.println(“ce testMap after changing variable from accessor methods:” + ce.getTestMap()); } } 3. What is Deep Copy vs Shallow Copy ? Shallow Copy Whenever we use default implementation of clone method we get shallow copy of object means it creates new instance and copies all the fields of object to that new instance and returns it as object type. clone() method of the object class support shallow copy of the object. If the object contains primitive as well as non-primitive or reference type variable in shallow copy, the cloned object also refers to the same object to which the original object refers as only the object references gets copied and not the referred objects themselves. If only primitive type fields or Immutable objects are there then there is no difference between shallow and deep copy in Java. Refer lines 57-72 to see shallow copy constructor in above example. Deep Copy Whenever we need own copy not to use default implementation we call it as deep copy, whenever we need deep copy of the object we need to implement according to our need. So for deep copy we need to ensure all the member class also implement the Cloneable interface and override the clone() method of the object class. Refer lines 35-54 to see Deep copy constructor in above example. When to use what There is no hard and fast rule defined for selecting between shallow copy and deep copy but normally we should keep in mind that if an object has only primitive fields, then obviously we should go for shallow copy, but if the object has references to other objects, then based on the requirement, shallow copy or deep copy should be done. If the references are not updated then there is no point to initiate a deep copy. 4. What are the advantages of immutable class in java? Immutable class is good for caching purpose because you don’t need to worry about the value changes. You can use static factory methods to provide methods like valueOf(), which can return an existing Immutable object from cache, instead of creating a new one. Other benefit of immutable class is that it is inherently thread-safe, so you don’t need to worry about thread safety in case of multi-threaded environment. The best use of the immutable objects is as the keys of a Map and values of Set. Once created the state of the immutable object can not be changed so there is no possibility of them getting into an inconsistent state. Please feel free to comment in case of any doubts.... Read more...Method Overloading and OverridingSeptember 9, 2018Interview1. What is the other name of Method Overloading? Method Overloading is also known as Static Polymorphism. 2. How will you implement method overloading in Java? In Java, a class can have multiple methods with same name but different arguments. It is called Method Overloading. To implement method overloading we have to create two methods with same name in a class and do one/more of the following: Different data type of parameters Different number of parameters Different sequence of data type of parameters. 3. What kinds of argument variations are allowed in Method Overloading? Method Overloading allows two methods with same name to differ in: 1. Number of parameters 2. Data type of parameters 3. Sequence of data type of parameters. 4. Why it is not possible to do method overloading by changing return type of method in java? If we change the return type of overloaded methods then it will lead to ambiguous behavior. How will clients know which method will return what type. Due to this different return type are not allowed in overloaded methods. 5. Is it allowed to overload main() method in Java? Yes, Java allows users to create many methods with same name ‘main’. But only public static void main(String[] args) method is used for execution. 6. How do we implement method overriding in Java? To override a method, we just provide a new implementation of a method with same name in subclass. So there will be at least two implementations of the method with same name. One implementation is in parent class. And another implementation is in child class. 7. Are we allowed to override a static method in Java? No. Java does not allow overriding a static method. If you create a static method with same name in subclass, then it is a new method, not an overridden method. 8. Why Java does not allow overriding a static method? To override a method, you need an instance of a class. Static method is not associated with any instance of the class. So the concept of overriding does not apply here. Therefore, Java does not allow overriding a static method. 9. Is it allowed to override an overloaded method? Yes. You can override an overloaded method in Java. 10. What is the difference between method overloading and method overriding in Java? Differences between method overloading and overriding are: Method overloading is static polymorphism. Method overriding is runtime polymorphism. Method overloading occurs within the same class. Method overriding happens in two classes with hierarchy relationship. Parameters must be different in method overloading. Parameters must be same in method overriding. Method overloading is a compile time concept. Method overriding is a runtime concept. 11. Does Java allow virtual functions? Yes. All instance methods in Java are virtual functions by default. Only class methods and private instance methods are not virtual methods in Java. 12. What is meant by covariant return type in Java? A covariant return type of a method is one that can be replaced by a “narrower” type when the method is overridden in a subclass. Let say class B is child of class A. There is a get() method in class A as well as class B. get() method of class A can return an instance of A, and get() method of class B return an instance of B. Here class B overrides get() method, but the return type is different. Before Java 5, any method that overrides the method of parent class would have same return type. From Java 5 onwards, a child class can override a method of parent class and the child class method can return an object that is child of object return by parent class method.... Read more...InheritanceSeptember 9, 2018Interview1. What is the purpose of ‘this’ keyword in java? In Java, ‘this’ keyword refers to current instance of the object. It is useful for differentiating between instance variables and local variables. It can be used to call constructors. Or it can be used to refer to the instance. In case of method overriding, this is used for falling the method of current class. 2. Explain the concept of Inheritance? Inheritance is an important concept in Object Oriented Programming. Some objects share certain characteristics and behavior. By using Inheritance, we can put the common behavior and characteristics in a base class which also known as super class. And then all the objects with common behavior inherit from this base class. It is also represented by IS-A relationship. Inheritance promotes, code reuse, method overriding and polymorphism. 3. Which class in Java is superclass of every other class? Java is an object oriented programming language. In Java, Object class is the superclass of every other class. 4. Why Java does not support multiple inheritance? Multiple Inheritance means that a class can inherit behavior from two or more parent classes. The issue with Multiple Inheritance is that both the parent classes may have different implementation for the same method. So they have different ways of doing the same thing. Now which implementation should the child class choose? This leads to ambiguity in Multiple Inheritance. This is the main reason for Java not supporting Multiple Inheritance in implementation. Lets say you have a class TV and another class AtomBomb. Both have method switchOn() but only TV has switchOff() method. If your class inherits from both these classes then you have an issue that you can switchOn() both parents, but switchOff will only switchOff() TV . But you can implement multiple interfaces in Java. 5. In OOPS, what is meant by composition? Composition is also known as “has-a” relationship. In composition, “has-a” relation relates two classes. E.g. Class Car has a steering wheel. If a class holds the instance of another class, then it is called composition. 6. How aggregation and composition are different concepts? In OOPS, Aggregation and Composition are the types of association relations. A composition is a strong relationship. If the composite object is destroyed, then all its parts are destroyed. E.g. A Car has a Steering Wheel. If Car object is destroyed, then there is no meaning of Steering Wheel. In Aggregation, the relationship is weaker than Composition. E.g. A Library has students. If a Library is destroyed, Students still exist. So Library and Student are related by Aggregation. A Library has Books. If Library is destroyed, the Books are also destroyed. Books of a Library cannot exist without the Library. So Book and Library are related by Composition. 7. Why there are no pointers in Java? In Java there are references instead of pointers. These references point to objects in memory. But there is no direct access to these memory locations. JVM is free to move the objects within VM memory. The absence of pointers helps Java in managing memory and garbage collection effectively. Also it provides developers with convenience of not getting worried about memory allocation and deallocation. 8. If there are no pointers in Java, then why do we get NullPointerException? In Java, the pointer equivalent is Object reference. When we use a . it points to object reference. So JVM uses pointers but programmers only see object references. In case an object reference points to null object, and we try to access a method or member variable on it, then we get NullPointerException. 9. What is the purpose of ‘super’ keyword in java? ‘super’ keyword is used in the methods or constructor of a child class. It refers to immediate parent class of an object. By using ‘super’ we can call a method of parent class from the method of a child class. We can also call the constructor of a parent class from the constructor of a child class by using ‘super’ keyword. 10. Is it possible to use this() and super() both in same constructor? No, Java does not allow using both super() and this() in same constructor. As per Java specification, super() or this() must be the first statement in a constructor. 11. What is the meaning of object cloning in Java? Object.clone() method is used for creating an exact copy of the object in Java. It acts like a copy constructor. It creates and returns a copy of the object, with the same class and with all the fields having same values as of the original object. One disadvantage of cloning is that the return type is an Object. It has to be explicitly cast to actual type. ... Read more...PolymorphismSeptember 9, 2018Interview1. What is Runtime Polymorphism? Runtime Polymorphism or Dynamic Polymorphism is the polymorphism that exists at runtime. In case of method overriding it is not known which method will be called at runtime. Based on the type of object, JVM decides the exact method that should be called. So at compile time it is not known which method will be called at run time. 2. Is it possible to achieve Runtime Polymorphism by data members in Java? No. We need to create Runtime Polymorphism by implementing methods at two levels of inheritance in Java. 3. Explain the difference between static and dynamic binding? In Static binding references are resolved at compile time. In Dynamic binding references are resolved at Run time. E.g. Person p = new Person(); p.walk(); // Java compiler resolves this binding at compile time. public void walk(Object o){ ((Person) o).walk(); // this is dynamic binding. } ... Read more...AbstractionSeptember 9, 2018Interview1. What is Abstraction in Object Oriented programming? Abstraction is the process of hiding certain implementation details of an object and showing only essential features of the object to outside world. It is different from Abstract class in Java. Abstraction process identifies commonalities and hides the complexity of implementation. It helps us in focusing on the interface that we share with the outside world 2. How is Abstraction different from Encapsulation? Abstraction happens at class level design. It results in hiding the implementation details. Encapsulation is also known as “Information Hiding”. An example of encapsulation is marking the member variables private and providing getter and setter for these member variables. 3. What is an abstract class in Java? An abstract class in Java has one or more abstract methods. An abstract method is just declared in the abstract class, but it is not implemented. An abstract class has to be extended in Java and its abstract methods have to be implemented by a child class. Also Java does not allow new instance of Abstract class. 4. Is it allowed to mark a method abstract method without marking the class abstract? No. Java specification says that if there is at least one abstract method in a class, the class has to be marked abstract. 5. Is it allowed to mark a method abstract as well as final? No. It will be contradictory statement to mark a method abstract as well as final. An abstract method has to be overridden by a child class. And a final method cannot be overridden. Therefore a method can be either abstract or final in Java. 6. Can we instantiate an abstract class in Java? No. We cannot create an instance of an abstract class in Java. 7. What is an interface in Java? An Interface in Java is an abstract type blueprint of a class. It contains the methods that a class must implement. It is like a protocol. It has method signatures and constant declarations. 8. Is it allowed to mark an interface method as static? Yes, from Java 8 onwards, we can define static and default methods in an interface. Prior to Java 8, it was not allowed. 9. Why an Interface cannot be marked as final in Java? A final method cannot be overridden. But an interface method has to be implemented by another class. So the interface method cannot be marked as final. 10. What is a marker interface? There are interfaces that do not have any data member or methods. These interfaces are called Marker interface. E.g. Serializable, Cloneable, Remote etc. 11. What can we use instead of Marker interface? We can use annotations instead of Marker interface. 12. How Annotations are better than Marker Interfaces? Annotations serve the purpose of conveying metadata about the class to its consumers without creating a separate type for it. Annotations are more powerful than a Marker interface. They allow programmers to pass more sophisticated information to classes that “consume” it. 13. What is the difference between abstract class and interface in Java? Differences between Abstract class and Interface are as follows: An abstract class can have implemented methods with body (non-abstract methods). Interface has only abstract methods. From Java 8 onwards, interface can have static/default methods in implemented form. An abstract class can have instance member variables. An interface cannot have instance variables. It can only have constants. An abstract class can have a constructor. Interface cannot have constructor. It has to be implemented by another class. A class can extend only one abstract class. A class can implement more than one interface. 14. Does Java allow us to use private and protected modifiers for variables in interfaces? No. All the variables in an interface are implicitly public. 15. How can we cast to an object reference to an interface reference? An Object that implements an Interface can be cast to the same Interface. Since An Object implementing an Interface already provides implementation for the methods of that Interface, it is allowed to do so as per the rules of Inheritance. ... Read more...Java BasicsSeptember 9, 2018Interview1. What is the difference between JDK and JRE? JDK stands for Java Development Kit. It contains the tools and libraries for development of Java programs. It also contains compilers and debuggers needed to compile Java program. JRE stands for Java Runtime Environment. This is included in JDK. JRE provides libraries and JVM that is required to run a Java program. 2. What is Java Virtual Machine (JVM)? Java Virtual Machine (JVM) is an abstract machine that executes Java Bytecode. There are different JVM for different hardware and software platforms. So JVM is platform dependent. JVM is responsible for loading, verifying and executing the Bytecode on a platform. 3. What are the different types of memory areas allocated by JVM? In java, JVM allocates memory to different processes, methods and objects. Some of the memory areas allocated by JVM are: ClassLoader: It is a component of JVM used to load class files. Class (Method) Area: It stores per-class structures such as the runtime constant pool, field and method data, and the code for methods. Heap: Heap is created a runtime and it contains the runtime data area in which objects are allocated. Stack: Stack stores local variables and partial results at runtime. It also helps in method invocation and return value. Each thread creates a private JVM stack at the time of thread creation. Program Counter Register: This memory area contains the address of the Java virtual machine instruction that is currently being executed. Native Method Stack: This area is reserved for all the native methods used in the application. 4. What is JIT compiler? Just In Time compiler also known as JIT compiler is used for performance improvement in Java. It is enabled by default. It is compilation done at execution time rather earlier. Java has popularized the use of JIT compiler by including it in JVM. 5. How Java platform is different from other platforms? Java is a platform independent language. Java compiler converts Java code in to byte code that can be interpreted by JVM. There are JVM written for almost all the popular platforms in the world. Java byte code can run on any supported platform in same way. Where as other languages require libraries compiled for a specific platform to run. 6. How does ClassLoader work in Java? In Java, ClassLoader is a class that is used to load files in JVM. ClassLoader loads files from their physical file locations e.g. Filesystem, Network location etc. There are three main types of ClassLoaders in Java. Bootstrap ClassLoader: This is the first ClassLoader. It loads classes from rt.jar file. Extension ClassLoader: It loads class files from jre/lib/ext location. Application ClassLoader: This ClassLoader depends on CLASSPATH to find the location of class files. If you specify your jars in CLASSPATH, then this ClassLoader will load them. 7. Why people say that Java is ‘write once and run anywhere’ language? You can write Java code on Windows and compile it in Windows platform. The class and jar files that you get from Windows platform can run as it is on Unix environment. So it is a truly platform independent language. Behind all this portability is Java byte code. Byte code generated by Java compiler can be interpreted by any JVM. So it becomes much easier to write programs in Java and expect those to run on any platform. Java compiler javac compiles java code and JVM java runs that code. 8. Do you think ‘main’ used for main method is a keyword in Java? No, main is just a name of method. There can be multiple methods with same name main in a class file. It is not a keyword in Java. 9. Can we write main method as public void static instead of public static void? No, you cannot write it like this. Any method has to first specify the modifiers and then the return value. The order of modifiers can change. We can write static public void main() instead of public static void main(). 10. In Java, if we do not specify any value for local variables, then what will be the default value of the local variables? Java does not initialize local variables with any default value. So these variables will be just null by default. 11. Let’s say, we run a java class without passing any arguments. What will be the value of String array of arguments in Main method? By default, the value of String array of arguments is empty in Java. It is not null. 12. What is the difference between byte and char data types in Java? Both byte and char are numeric data types in Java. They are used to represent numbers in a specific range. Major difference between them is that a byte can store raw binary data where as a char stores characters or text data. Usage of char is E.g. char ch = ‘x’; Byte values range from -128 to 127. A byte is made of 8 bits. But a char is made of 16 bits. So it is equivalent to 2 bytes. ... Read more...OOPS ConceptsSeptember 9, 2018Interview1. What are the main principles of Object Oriented Programming? Main principles of Object Oriented Programming (OOPS) are: Abstraction Encapsulation Inheritance Polymorphism 2. What is the difference between Object Oriented Programming language and Object Based Programming language? Object Oriented Programming languages like Java and C++ follow concepts of OOPS like- Encapsulation, Abstraction, Polymorphism and Inheritance etc. Object Based Programming languages follow some features of OOPS but they do not provide support for Polymorphism and Inheritance. Egg. JavaScript, VBScript etc. Object Based Programming languages provide support for Objects and you can build objects from constructor. They languages also support Encapsulation. These are also known as Prototype-oriented languages. 3. In Java what is the default value of an object reference defined as an instance variable in an Object? All the instance variable object references in Java are null. 4. Why do we need constructor in Java? Java is an object-oriented language, in which we create and use objects. A constructor is a piece of code similar to a method. It is used to create an object and set the initial state of the object. A constructor is a special function that has same name as class name. Without a constructor, there is no other way to create an object. By default, Java provides a default constructor for every object. If we overload a constructor then we have to implement default constructor. 5. Why do we need default constructor in Java classes? Default constructor is the no-argument constructor that is automatically generated by Java if no other constructor is defined. Java specification says that it will provide a default constructor if there is no overloaded constructor in a class. But it does not say anything about the scenario in which we write an overloaded constructor in a class. We need at least one constructor to create an object, that’s why Java provides a default constructor. When we have overloaded constructor, then Java assumes that we want some custom treatment in our code. Due to which it does not provide default constructor. But it needs default constructor as per the specification. So it gives error. 6. What is the value returned by Constructor in Java? When we call a constructor in Java, it returns the object created by it. That is how we create new objects in Java. 7. Can we inherit a Constructor? No, Java does not support inheritance of constructor. 8. Why constructors cannot be final, static, or abstract in Java? If we set a method as final it means we do not want any class to override it. But the constructor (as per Java Language Specification) cannot be overridden. So there is no use of marking it final. If we set a method as abstract it means that it has no body and it should be implemented in a child class. But the constructor is called implicitly when the new keyword is used. Therefore it needs a body. If we set a method as static it means that it belongs to the class, but not a particular object. The constructor is always called to initialize an object. Therefore, there is no use of marking constructor static.... Read more...Connecting to MYSQL docker containerAugust 31, 2018DockerCreating a MYSQL server container in Docker Step 1 : Pull MySql image from docker hub. Following command will pull the MYSQL version 5.6 image. docker pull mysql:5.6 Step 2: Run a container from this image. ‘-name’ gives a name to the container. ‘ -e’ specifies run time variables you need to set. Set the runtime variables for the MySQL container- MYSQL_ROOT_PASSWORD=root MYSQL_DATABASE=testdb MYSQL_USER=test MYSQL_PASSWORD=test These options are self explanatory. ‘-d’ tells the docker to run the container in background. docker run –name=mysql-dev-server -e MYSQL_ROOT_PASSWORD=root -e MYSQL_USER=test -e MYSQL_PASSWORD=test -e MYSQL_DATABASE=testdb -d mysql This will output a container id as shown below, which means that the container is started in the background properly. Step 3: Then check the status of the container by issuing, ‘docker ps -a’ command docker ps -a Now you should be able to see that MySQL is running on port 3306. Step 4: Find the IP of the container using following. Check out the “IPAddress” from the output, this will tell you the ip address. docker inspect mysql-dev-server Now you should be able to connect to MySQL using this ip address on port 3306. Step 5: You can check the logs of the running container use the following command docker logs mysql-dev-server Isn’t it easy? You have created a MYSQL database server with just couple of commands. Accessing MYSQL database through WEB Interface (phpMyAdmin) Step 1: In order to link the MYSQL container to phpMyAdmin , you need to fire below docker command – docker pull phpmyadmin/phpmyadmin docker run –name myphpadmin -d –link mysql-dev-server:db -p 8080:80 phpmyadmin/phpmyadmin First command will pull the phpmyadmin image and second will create the phpmyadmin container named ‘myphpadmin’ and link it to ‘mysql-dev-server’ container which we created earlier – Step 2: Access the MYSQL database from phpMyAdmin Now you can connect to this MYSQL database docker container from phpmyadmin . This will show up below page once you hit the URL (http://192.168.99.100:8080) Note : 192.168.99.100 is the default IP of docker machine . This can be seen on the docker Toolbox console once it loaded. In case of windows please refer below screenshot to get the docker machine’s default IP address – Once you hit the URL http://192.168.99.100:8080 , you can see phpmyAdmin login screen . You need to enter database details like username and password in order and click go – Now you can access the testdb database which you have created using MYSQL docker image.... Read more...Dockerizing a Spring boot Application with MySQL DatabaseAugust 21, 2018DockerDockerizing a Spring boot Data JPA Application with MySQL Database Here we are going to deploy Spring boot with MYSQL application on AWS EC2 (Ubuntu) instance. So before to that we need to adhere to pre-requisites of installing Java , Git and maven We will have two docker containers , Container 1: One for hosting MYSQL database i.e. Database server . Container 2: One for hosting Spring boot application i.e. Web/Application server . Spring boot application has embedded tomcat server for our deployment. Before going to dokerize our web application , we need to first create a MYSQL database server. So you need to visit below link in order to Create MYSQL database docker container. Once the database server is up and running , we will create separate container for our spring boot web application following below steps – Step 1: Download the application to be Dockerized Create folder docker under /usr/docker sudo mkdir docker Then cd into it – cd /usr/docker Then download application source code from repository to local system. Here in our case we have git repository. sudo git clone https://github.com/AnupBhagwat7/TodoListManagerJPA_Docker.git This is a spring boot application connecting MYSQL database through data JPA . Step 2: Change the application.properties file Change the application.properties file to point to the MYSQL database server which we created earlier . spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8081 ## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties) spring.datasource.url = jdbc:mysql://mysql-dev-server:3306/testdb spring.datasource.username = test spring.datasource.password = test ## Hibernate Properties # The SQL dialect makes Hibernate generate better SQL for the chosen database spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect # Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto = update server.error.whitelabel.enabled=false Step 3: Maven clean and package the application cd TodoListManagerJPA_Docker/ mvn clean package Step 4: Define a docker image with Dockerfile touch Dockerfile Dockerfile is where we define the docker image and specify all the configurations required to run the app. Following is the Dockerfile for our spring boot application – # Start with a base image containing Java runtime FROM openjdk:8-jdk-alpine # Add Maintainer Info LABEL maintainer=”[email protected]” # Add a volume pointing to /tmp VOLUME /tmp # Make port 8081 available to the world outside this container EXPOSE 8081 # The application’s jar file ARG JAR_FILE=target/TodoListManagerJPA_Docker.jar # Add the application’s jar to the container ADD ${JAR_FILE} TodoListManagerJPA_Docker.jar # Run the jar file ENTRYPOINT [“java”,”-jar”,”/TodoListManagerJPA_Docker.jar”] FROM openjdk:8-jdk-alpine – A docker image can use another image available in the docker registry as its base or parent image. In the above example, we use the openjdk:8-jdk-alpine image as our base image. LABEL maintainer – The LABEL instruction is used to add metadata to the image. In the above Dockerfile, we have added some info about the maintainer of the image through LABEL instruction. VOLUME: Volumes are a mechanism to persist data generated by the container on the Host OS, and share directories from the Host OS with the container. You can mount a VOLUME with path /var/log in the Dockerfile, and then specify the directory on the Host OS to which this mount point will be mapped to while running the container. After that, you’ll be able to access the logs from the mapped directory on the Host OS. In the above Dockerfile, we created a mount point with path /tmp because this is where the spring boot application creates working directories for Tomcat by default. Although it’s not required for this spring boot application because who cares about tomcat directories. But if you want to store stuff like tomcat access logs, then VOLUMES are very useful. EXPOSE: As the name suggests, this instruction allows you to expose a certain port to the outside world. You can skip this step as we are going to user -p option while running the image for mapping the docker container port with host machine’s port. ARG: The ARG instruction defines a variable with a default value. ADD: The ADD instruction is used to copy new files and directories to the docker image. ENTRYPOINT: This is where you configure how the application is executed inside the container. Step 5: Build the Docker image Now that we have defined the Dockerfile, let’s build a docker image for our application. Type the following command from the root directory of the project to build the docker image . docker build -t spring-boot-mysql . spring-boot-mysql is name of the docker image and . is to define path which contains Dockerfile to be referred to build image from. Step 4: Link and Run the docker image Once you have a docker image, you can run it using docker run command like so – docker run –name spring-boot-mysql -d –link mysql-dev-server:db -p 8081:8081 spring-boot-mysql Output: In the run command, we have specified that the port 8081 on the container should be mapped to the port 8081 on the Host OS(Local Machine). Once the application is started, you should be able to access it at http://192.168.99.100:8081/ 192.168.99.100 – I have used Windows 10 docker toolbox for this demo . This is the default IP of the Docker machine which can be seen after docker toolbox is loaded as below – -it option – interactive mode . -p option- mapping containers port to host machine’s port . mysql-dev-server – Its the MYSQL database container . spring-boot-mysql – Its Spring boot application container. –link – To link these two containers together -d option – To run the container in the background or Detached mode. Step 5: Check the output of above Application in browser http://192.168.99.100:8081/ Step 6: Push the docker image to docker hub We can push our image to docker hub so that other people can use it . Below steps are required to push the image to docker hub – Login with your docker ID – [email protected]:~$ docker login Login with your Docker ID to push and pull images from Docker Hub. If you don’t have a Docker ID, head over to https://hub.docker.com to create one. Username: anupbhagwat7 Password: Login Succeeded Tag the image – docker tag image username/repository:tag We will tag our current image – docker tag spring-boot-mysql anupbhagwat7/spring-boot-mysql:0.0.1-SNAPSHOT Replace my name(anupbhagwat7) with your respective docker ID. Once the image is tagged , you need to push it to docker hub. Push the image to docker hub docker push anupbhagwat7/spring-boot-mysql:0.0.1-SNAPSHOT That’s it, You can now access this image on docker hub through below link – https://hub.docker.com/r/anupbhagwat7/spring-boot-mysql/ Step 7: Pull the docker image from docker hub and run it After we publish the image to docker hub, anyone can pull this image and run it in their environment. Type the following command to pull and run the image on your machine that we just pushed to docker hub – docker run -it -p 8080:8080 anupbhagwat7/spring-boot-mysql:0.0.1-SNAPSHOT The docker run command pulls the image from docker hub if it is not available locally, and then runs it. OR You can pull the image and run it with two different commands – docker pull anupbhagwat7/spring-boot-mysql docker run -it -p 8081:8081 anupbhagwat7/spring-boot-mysql:0.0.1-SNAPSHOT You see how easy it is to share your image with others. People don’t need to install anything whatsoever to run your application. They just need to pull the image and run it with docker. Using dockerfile-maven-plugin to Automate the Docker image creation and publishing We can automate everything from building the docker image to publishing it on docker hub using dockerfile-maven-plugin. Add below plugin code to you projects pom.xml file – <!– This plugin is used to create a docker image and publish the image to docker hub–> <plugin> <groupId>com.spotify</groupId> <artifactId>dockerfile-maven-plugin</artifactId> <version>1.4.0</version> <configuration> <!– replace `anupbhagwat7` with your docker id–> <repository>anupbhagwat7/spring-boot-websocket-chat-demo</repository> <tag>${project.version}</tag> <buildArgs> <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE> </buildArgs> </configuration> <executions> <execution> <id>default</id> <phase>install</phase> <goals> <goal>build</goal> <goal>push</goal> </goals> </execution> </executions> </plugin> The plugin’s configuration includes the remote repository name and the repository tag. Please replace the username anupbhagwat7 with your docker Id in the <repository> element. We’re also passing the JAR_FILE argument inside <buildArgs> element. Remember we had added ARG JAR_FILE instruction to the Dockerfile? The argument passed here will override that value. Here is how you can build the docker image using docker-file-maven plugin – mvn package dockerfile:build This command will package the application into jar file and then creates docker image. Finally, you can push the docker image to the docker registry using dockerfile:push command – mvn dockerfile:push Now to automate it further, we need register the dockerfile:build and dockerfile:push goals to the install phase of maven build life cycle using the <executions> tag. So whenever you run mvn install, the build and push goals of dockerfile-maven-plugin are executed, and your docker image is built and pushed to docker hub. The dockerfile-maven-plugin uses the authentication information stored in any configuration files ~/.dockercfg or ~/.docker/config.json to push the docker image to your docker profile. These configuration files are created when you login to docker via docker login. You can also specify authentication details in maven settings.xml or pom.xml files.... Read more...Dockerizing Spring boot Rest Webservice ApplicationAugust 16, 2018DockerDockerizing a Spring boot Rest Webservice Application Here we are going to deploy Spring boot application on AWS EC2 (Ubuntu) instance. So before to that we need to adhere to pre-requisites of installing Java , Git and maven Step 1: Download the application to be Dockerized Create folder docker under /usr/docker sudo mkdir docker Then cd into it – cd /usr/docker Then download application source code from repository to local system. Here in our case we have git repository. sudo git clone https://github.com/AnupBhagwat7/SpringBootRestful.git This is a simple spring boot Restful Webservice application project. Step 2: Maven clean and package the application cd SpringBootRestful/ mvn clean package Step 3: Define a docker image with Dockerfile touch Dockerfile Dockerfile is where we define the docker image and specify all the configurations required to run the app. Following is the Dockerfile for our spring boot application – # Start with a base image containing Java runtime FROM openjdk:8-jdk-alpine # Add Maintainer Info LABEL maintainer=”[email protected]” # Add a volume pointing to /tmp VOLUME /tmp # Make port 8080 available to the world outside this container EXPOSE 8080 # The application’s jar file ARG JAR_FILE=target/SpringBootRestful-0.0.1-SNAPSHOT.jar # Add the application’s jar to the container ADD ${JAR_FILE} SpringBootRestful.jar # Run the jar file ENTRYPOINT [“java”,”-jar”,”/SpringBootRestful.jar”] FROM openjdk:8-jdk-alpine – A docker image can use another image available in the docker registry as its base or parent image. In the above example, we use the openjdk:8-jdk-alpine image as our base image. LABEL maintainer – The LABEL instruction is used to add metadata to the image. In the above Dockerfile, we have added some info about the maintainer of the image through LABEL instruction. VOLUME: Volumes are a mechanism to persist data generated by the container on the Host OS, and share directories from the Host OS with the container. You can mount a VOLUME with path /var/log in the Dockerfile, and then specify the directory on the Host OS to which this mount point will be mapped to while running the container. After that, you’ll be able to access the logs from the mapped directory on the Host OS. In the above Dockerfile, we created a mount point with path /tmp because this is where the spring boot application creates working directories for Tomcat by default. Although it’s not required for this spring boot application because who cares about tomcat directories. But if you want to store stuff like tomcat access logs, then VOLUMES are very useful. EXPOSE: As the name suggests, this instruction allows you to expose a certain port to the outside world. You can skip this step as we are going to user -p option while running the image for mapping the docker container port with host machine’s port. ARG: The ARG instruction defines a variable with a default value. ADD: The ADD instruction is used to copy new files and directories to the docker image. ENTRYPOINT: This is where you configure how the application is executed inside the container. Step 3: Build the Docker image Now that we have defined the Dockerfile, let’s build a docker image for our application. Type the following command from the root directory of the project to build the docker image . docker build -t spring-rest . spring-rest is name of the docker image and . is to define path which contains Dockerfile to be referred to build image from. Output: Step 4: Run the docker image Once you have a docker image, you can run it using docker run command like so – docker run -it -p 8080:8080 spring-rest Output: In the run command, we have specified that the port 8080 on the container should be mapped to the port 8080 on the Host OS(Local Machine). Once the application is started, you should be able to access it at http://EC2_INSTANCE_IP:8080/tasks -it option – interactive mode . -p option- mapping containers port to host machine’s port . spring-rest – Its Spring boot application container. The container runs in the foreground, and pressing CTRL + C will stop it. Let’s now see how to run the container in the background. Running the docker image in the background, in detached mode. You can use the -d option in docker run command to run the container in the background – docker run -d -it -p 8080:8080 spring-rest Step 5: Check response in POSTMAN tool Below is the response from webservice – Step 6: Push the docker image to docker hub We can push our image to docker hub so that other people can use it . Below steps are required to push the image to docker hub – Login with your docker ID – [email protected]:~$ docker login Login with your Docker ID to push and pull images from Docker Hub. If you don’t have a Docker ID, head over to https://hub.docker.com to create one. Username: anupbhagwat7 Password: Login Succeeded Tag the image – docker tag image username/repository:tag We will tag our current image – docker tag spring-rest anupbhagwat7/spring-rest:0.0.1-SNAPSHOT Replace my name(anupbhagwat7) with your respective docker ID. Once the image is tagged , you need to push it to docker hub. Push the image to docker hub docker push anupbhagwat7/spring-rest:0.0.1-SNAPSHOT That’s it, You can now access this image on docker hub through below link – https://hub.docker.com/r/anupbhagwat7/spring-rest/ Step 7: Pull the docker image from docker hub and run it After we publish the image to docker hub, anyone can pull this image and run it in their environment. Type the following command to pull and run the image on your machine that we just pushed to docker hub – docker run -it -p 8080:8080 anupbhagwat7/spring-rest:0.0.1-SNAPSHOT The docker run command pulls the image from docker hub if it is not available locally, and then runs it. OR You can pull the image and run it with two different commands – docker pull anupbhagwat7/spring-rest docker run -it -p 8080:8080 anupbhagwat7/spring-rest:0.0.1-SNAPSHOT You see how easy it is to share your image with others. People don’t need to install anything whatsoever to run your application. They just need to pull the image and run it with docker. Using dockerfile-maven-plugin to Automate the Docker image creation and publishing We can automate everything from building the docker image to publishing it on docker hub using dockerfile-maven-plugin. Add below plugin code to you projects pom.xml file – <!– This plugin is used to create a docker image and publish the image to docker hub–> <plugin> <groupId>com.spotify</groupId> <artifactId>dockerfile-maven-plugin</artifactId> <version>1.4.0</version> <configuration> <!– replace `anupbhagwat7` with your docker id–> <repository>anupbhagwat7/spring-boot-websocket-chat-demo</repository> <tag>${project.version}</tag> <buildArgs> <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE> </buildArgs> </configuration> <executions> <execution> <id>default</id> <phase>install</phase> <goals> <goal>build</goal> <goal>push</goal> </goals> </execution> </executions> </plugin> The plugin’s configuration includes the remote repository name and the repository tag. Please replace the username anupbhagwat7 with your docker Id in the <repository> element. We’re also passing the JAR_FILE argument inside <buildArgs> element. Remember we had added ARG JAR_FILE instruction to the Dockerfile? The argument passed here will override that value. Here is how you can build the docker image using docker-file-maven plugin – mvn package dockerfile:build This command will package the application into jar file and then creates docker image. Finally, you can push the docker image to the docker registry using dockerfile:push command – mvn dockerfile:push Now to automate it further, we need register the dockerfile:build and dockerfile:push goals to the install phase of maven build life cycle using the <executions> tag. So whenever you run mvn install, the build and push goals of dockerfile-maven-plugin are executed, and your docker image is built and pushed to docker hub. The dockerfile-maven-plugin uses the authentication information stored in any configuration files ~/.dockercfg or ~/.docker/config.json to push the docker image to your docker profile. These configuration files are created when you login to docker via docker login. You can also specify authentication details in maven settings.xml or pom.xml files.... Read more...Basic Docker commandsAugust 16, 2018Dockerdocker run hello-world Docker looks for this image on our local system. If its not on local then,it downloads hello-world image from docker hub and runs it . docker run -it ubuntu bash We downloaded an Ubuntu Linux image and started a login shell as root inside it. The -it flags allow us to interact with the shell. docker ps -a It lists all running containers on our system. [email protected]:/etc/bash_completion.d$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 830992bb76cd hello-world “/hello” 2 minutes ago Exited (0) 2 minutes ago sleepy_fermi From this, we can see that the hello-world container is still in memory. The status column tells us that it’s exited. The names column has a name, sleepy_fermi, that Docker assigned to the container for us. Let’s run this image again with docker run hello-world. This time console output will not be same as image will not be downloaded again as its already downloaded. Run docker ps -a again , what it will show? We see two stopped instances of hello-world, with two different names. Docker created an additional container. It didn’t reuse the first. When we told Docker to run an image named hello-world, it did exactly that; it ran a new instance of the image. If we want to reuse a container, we refer to it by name. docker stop sleepy_fermi This will stop the running instance in a container. We need to pass CONTAINER NAME as a parameter to this command. docker rm sleepy_fermi This will remove the container from docker . We need to pass CONTAINER NAME as a parameter to this command. docker image ls This produces a listing of images on our system. We see Ubuntu and the single hello-world image since we only needed that single image to run two containers. docker image rm <<IMAGE_NAME>> Removes the image which we have downloaded on local . docker build -t <<IMAGE_NAME>> . This will build the image for any custom application from the configuration done in Dockerfile -t – This option is for <<IMAGE_NAME>> – We can assign any name as per our wish to image. dot(.) – This is reference to the current directory which might be used for building war/jar file. docker run -v /full/path/to/html/directory:/usr/share/nginx/html:ro -p 8080:80 -d nginx Sharing local resources with Container – As of now , we have run independent images. But we have nginx image which can share the data on host OS with the containers. Here we an share the data on host OS or Network resources with containers. [email protected]:/var/test$ docker run -v /var/test/:/usr/share/nginx/html:ro -p 8080:80 -d nginx Unable to find image ‘nginx:latest’ locally latest: Pulling from library/nginx be8881be8156: Pull complete 32d9726baeef: Pull complete 87e5e6f71297: Pull complete Digest: sha256:d85914d547a6c92faa39ce7058bd7529baacab7e0cd4255442b04577c4d1f424 Status: Downloaded newer image for nginx:latest ee6c7a8fd3a7964c9ea6da35793a7244bf878d367d2d0930061da140380cd14d Command: docker run -v /full/path/to/html/directory:/usr/share/nginx/html:ro -p 8080:80 -d nginx When we execute this command line, we see Docker download the Nginx image and then start the container. /full/path/to/html/directory – Path on host OS where we can keep our files to be hosted. /usr/share/nginx/html:ro – Path to container -p 8080:80 – maps network service port 80 in the container to 8080 on our host system. -d – detaches the container from our command line session. nginx – the name of the image.... Read more...Installing Java, Git and Maven on UbuntuAugust 16, 2018DockerJava Java and the JVM (Java’s virtual machine) are widely used and required for many kinds of software. This article will guide you through the process of installing and managing different versions of Java using apt-get. The easiest option for installing Java is using the version packaged with Ubuntu. Specifically, this will install OpenJDK 8, the latest and recommended version. First, update the package index. sudo apt-get update Next, install Java. Specifically, this command will install the Java Runtime Environment (JRE). sudo apt-get install default-jre There is another default Java installation called the JDK (Java Development Kit). The JDK is usually only needed if you are going to compile Java programs or if the software that will use Java specifically requires it. The JDK does contain the JRE, so there are no disadvantages if you install the JDK instead of the JRE, except for the larger file size. You can install the JDK with the following command: sudo apt-get install default-jdk Setting the JAVA_HOME Environment Variable Many programs, such as Java servers, use the JAVA_HOME environment variable to determine the Java installation location. To set this environment variable, we will first need to find out where Java is installed. You can do this by executing the same command as in the previous section: sudo update-alternatives –config java Copy Copy the path from your preferred installation and then open /etc/environment using nano or your favorite text editor. sudo nano /etc/environment At the end of this file, add the following line, making sure to replace the highlighted path with your own copied path. JAVA_HOME=”/usr/lib/jvm/java-8-openjdk-amd64/jre/” Save and exit the file, and reload it. source /etc/environment You can now test whether the environment variable has been set by executing the following command: echo $JAVA_HOME Git The easiest way of getting git installed and ready to use is by using Ubuntu’s default repositories. This is the fastest method, but the version may be older than the newest version. If you need the latest release, consider following the steps to compile git from source. You can use the apt package management tools to update your local package index. Then, you can download and install the program: sudo apt-get update sudo apt-get install git This will download and install git to your system. You will still have to complete the configuration steps as below – git config –global user.name “Your Name” git config –global user.email “[email protected]” We can see all of the configuration items that have been set by typing: git config –list Maven The maven package always comes with latest Apache Maven.You can download and install maven using below commands: sudo apt-get update sudo apt-get install maven Run command mvn –version to verify your installation.... Read more...Installation of Docker on Windows 10 and EC2 Ubuntu InstanceAugust 14, 2018Docker1. Installation on Windows On windows , we have two different installers for docker . If you have Microsoft windows 10 Professional Or Enterprise 64 bit then you have default docker installer and for all previous versions of windows you need to install Docker toolbox. Docker Installation Link 2. Installation on Ubuntu (EC2 Instance) We need an AWS account (http://aws.amazon.com/) Choose EC2 from Amazon Web Services Console. From EC2 Dashboard, click on Launch Instance: Click the Select button for a 64Bit Ubuntu image. (i.e. Ubuntu Server 14.04 LTS) Click the Next: Configure Instance Details button at the bottom right. On the Configure Instance Details step, expand the Advanced Details section. Under User data, select As text. Enter #include https://get.docker.com into the instance User Data. It will bootstrap Docker by running the shell script located at this URL. We may need to set up our Security Group to allow SSH. By default all incoming ports to our new instance will be blocked by the AWS Security Group, so we might just get timeouts when we try to connect. Creating a new key pair: After a few more standard choices where defaults are probably ok, our AWS Ubuntu instance with Docker should be running! Connect to created EC2 instance using MobaXterm tool . First you have to select SSH session and then put the details like EC2 instance public IP , username , .pem file address and hit “Ok” as below – Install Docker on Ubuntu – To install the latest Ubuntu package (may not be the latest Docker release): [email protected]:~$ sudo apt-get update [email protected]:~$ sudo apt-get install docker.io Then, to enable tab-completion of Docker commands in BASH, either restart BASH or: source /etc/bash_completion.d/docker If this command doesn’t work and throws error like “can’t read /etc/bash_completion.d/docker: No such file or directory” then create docker file inside /etc/bash_completion.d directory. Now check if docker is running – [email protected]:/etc/bash_completion.d$ service docker status ● docker.service – Docker Application Container Engine Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2018-08-15 23:59:39 UTC; 32min ago If it’s not running, we can start it with start argument: [email protected]:/etc/bash_completion.d$ service docker start... Read more...What is docker and why docker?August 14, 2018DockerWhat is Docker? Docker is a platform for packaging, deploying and running applications. Docker applications run in containers that can be used on any system: a developer’s laptop, desktop, VM, Cloud etc. It packages applications as images that contain everything needed to run them: Code, Runtime environment, Libraries and Configuration. A running instance of a docker image is called a docker container. Docker containers don’t run in their own virtual machines, but share a Linux kernel. Compared to virtual machines, containers use less memory and less CPU. However, a Linux runtime is required for Docker. Implementations on non-Linux platforms such as macOS and Windows 10 use a single Linux virtual machine. The containers share this system. Why Docker Containers? Footprint: 100-1000 containers on one machine Small Disk/CPU requirements as compared to VM’s Portability Supported by all Cloud providers Speed: Boots in seconds Isolation and encapsulation of application dependencies. Ability to scale efficiently, easily, and in real time. Enhances efficiency via easy reuse of images. Containerization is increasingly popular because containers are: Flexible: Even the most complex applications can be containerized. Lightweight: Containers leverage and share the host kernel. Interchangeable: You can deploy updates and upgrades on-the-fly. Portable: You can build locally, deploy to the cloud, and run anywhere. Scalable: You can increase and automatically distribute container replicas. Stackable: You can stack services vertically and on-the-fly. Docker containers are built on top of Docker Engine. Each container operates on common Linux kernel of host machine. All needs for our App are defined in single tiny text file Dockerfile A sample of Dockerfile – the following few lines construct the whole environment which is production ready: FROM ubuntu:16:04 RUN apt-get install -y redis-server EXPOSE 5379 ENTRYPOINT [“/usr/bin/redis-server”] Containers contain everything our app needs: Binaries Libraries File system Containers use the following items from the host: Networks Kernel Docker : Please find below video explaining the above concept.... Read more...Difference between Virtual Machines and Docker ContainersAugust 14, 2018DockerVirtual Machines Vs Docker Containers – VMs can be compared with containers on below factors – Execution – The VM model blends an application, a full guest OS, and disk emulation. In contrast, the container model uses just the application’s dependencies and runs them directly on a host OS. Isolation – Containers do not launch a separate OS for each application, but share the host kernel while maintaining the isolation of resources and processes where required. Boot time – The fact that a container does not run its own OS instance reduces dramatically the overhead associated with starting and running instances. Startup time can be drastically reduced to few seconds as compared to VMs which generally takes several minutes to boot up. Scalability – The number of containers running on a typical server can reach dozens or even hundreds. The same server, in contrast, might support 10 to 15 VMs. Below diagram show the differences between VMs and Containers – CONTAINERS Containers are an abstraction at the app layer that packages code and dependencies together. Multiple containers can run on the same machine and share the OS kernel with other containers, each running as isolated processes in user space. Containers take up less space than VMs (container images are typically tens of MBs in size), can handle more applications and require fewer VMs and Operating systems. VIRTUAL MACHINES Virtual machines (VMs) are an abstraction of physical hardware turning one server into many servers. The hypervisor allows multiple VMs to run on a single machine. Each VM includes a full copy of an operating system, the application, necessary binaries and libraries – taking up tens of GBs. VMs can also be slow to boot. Please find below video explaining the above concept.... Read more...Docker HistoryAugust 13, 2018DockerDocker History Docker was created as the internal tool in the platform as a service company, dotCloud . In March 2013, it was released to the public as open source.Its source code is freely available to everyone on GitHub at: https://github.com/docker/docker. Kubernetes is a tool developed by Google for deploying containers across clusters of computers.It compliments Docker when it comes to orchestration, automating deployment, managing and scaling containers; it manages workloads for Docker nodes by keeping container deployments balanced across a cluster. Kubernetes also provides ways for containers to communicate with each other, without the need for opening network ports. Kubernetes is also an open source project, living on the GitHub at https://github.com/ kubernetes/kubernetes. The idea behind Docker The idea behind Docker is to pack an application with all the dependencies it needs into a single standardized unit for the deployment called as image.Those dependencies can be binaries, libraries, JAR files, configuration files, scripts and so on. Docker wraps up all of it into a complete filesystem that contains everything your Java application needs to run the virtual machine itself, the application server such as Wildfly or Tomcat, the application code, runtime libraries and basically everything you would install and deploy on the server to make your application run. Packaging all of this into a complete image guarantees that it is portable; it will always run in the same way, no matter what environment it is deployed in. With Docker, you can run Java applications without having to install a Java runtime on the host machine. All the problems related to incompatible JDK or JRE, wrong version of the application server, and so on are gone.Upgrades are also easy and effortless, you just run the new version of your container on the host. If you need to do some cleanup, you can just destroy the Docker image and it’s as though nothing ever happened. Think about Docker, not as a programming language or a framework, but rather as a tool that helps in solving the common problems such as installing, distributing and managing the software. It allows developers and DevOps to build, ship, and run their code anywhere. Having all of your application code and runtime dependencies packaged as a single and complete unit of software may seem the same as a virtualization engine, but it’s far from that, as we will explain difference between Virtualization and Containerization in next section.... Read more...Spring Bean ScopesJuly 22, 2018Spring CoreIn this example , we will see bean scopes in spring container . In Spring 5 below scopes (websocket) have been newly introduced – SCOPE DESCRIPTION singleton (default) Single bean object instance per spring IoC container prototype Opposite to singleton, it produces a new instance each and every time a bean is requested. request Return a single bean instance per HTTP request.Only valid in web-aware Spring ApplicationContext. session Return a single bean instance per HTTP session.Only valid in web-aware Spring ApplicationContext. application A single instance will be created and available during complete lifecycle of ServletContext.Only valid in web-aware Spring ApplicationContext. websocket A single instance will be created and available during complete lifecycle of WebSocket.Only valid in web-aware Spring ApplicationContext. Tools used to create below project – Spring 5.0.7.RELEASE Maven 3.3 Java 8 Eclipse Neon.2 Github Link : Download Step 1: Create Simple Maven Project with Spring Configuration Step 2: Configure maven dependencies Below pom.xml file contains the dependencies required for spring project – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringBeanScopesDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringBeanScopesDemo</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.7.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!– Spring 5 dependencies –> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project> Below project structure will be created for you by Eclipse . Step 3: Create City.java under com.myjavablog.beans package – City.java package com.myjavablog.beans; /** * @author anupb * */ public class City { String cityName; public String getcityName() { return cityName; } public void setcityName(String cityName) { this.cityName = cityName; } } These are bean files where we have only getters and setters defined. Step 4: Create ApplicationContext.xml under /src/main/resources- ApplicationContext.xml <?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:context=”http://www.springframework/schema/context” xmlns:mvc=”http://www.springframework.org/schema/mvc” xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd”> <!– Default Singleton scope bean –> <bean id=”CitySingletonBean” class=”com.myjavablog.beans.City”> </bean> <!– Proptotype scope bean–> <bean id=”CityPrototypeBean” class=”com.myjavablog.beans.City” scope=”prototype”> </bean> </beans> Step 5: Create a BeanScopesMain.java under com.myjavablog package – package com.myjavablog; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.myjavablog.beans.City; public class BeanScopesMain { public static void main(String[] args) { @SuppressWarnings(“resource”) ApplicationContext beanFactory = new ClassPathXmlApplicationContext(“ApplicationContext.xml”); //Default Singleton scope bean City singletonBeanInstance1 = (City) beanFactory.getBean(“CitySingletonBean”); singletonBeanInstance1.setcityName(“Pune”); System.out.println(“Singleton Bean value: “+singletonBeanInstance1.getcityName()+”———- Instance hashcode: “+singletonBeanInstance1.hashCode()); City singletonBeanInstance2 = (City) beanFactory.getBean(“CitySingletonBean”); System.out.println(“Singleton Bean value: “+singletonBeanInstance2.getcityName() +”———- Instance hashcode: “+singletonBeanInstance2.hashCode()); //Proptotype scope bean City prototypeBeanInstance1 = (City) beanFactory.getBean(“CityPrototypeBean”); prototypeBeanInstance1.setcityName(“Pune”); System.out.println(“Prototype Bean value: “+prototypeBeanInstance1.getcityName()+”———- Instance hashcode: “+prototypeBeanInstance1.hashCode()); City prototypeBeanInstance2 = (City) beanFactory.getBean(“CityPrototypeBean”); prototypeBeanInstance2.setcityName(“Pune”); System.out.println(“Prototype Bean value: “+prototypeBeanInstance2.getcityName()+”———- Instance hashcode: “+prototypeBeanInstance2.hashCode()); } } We have created ApplicationContext which actually loads bean definitions from XML configuration. Output: Singleton Bean value: Pune———- Instance hashcode: 1509563803 Singleton Bean value: Pune———- Instance hashcode: 1509563803 Prototype Bean value: Pune———- Instance hashcode: 684874119 Prototype Bean value: null———- Instance hashcode: 1157740463 In case of Singleton bean, When We firstly called getBean and retrieved city object and set cityName to “Pune” and when second time we called getBean method it did nothing but returned same object with cityName as “Pune”. Both the objects has same hashcodes as its same object. In case of Prototype bean,When We firstly called getBean and retrieved city object and set cityName to “Pune”and when second time we called getBean method it returned new object with cityName as “null”. Both the objects has different hashcodes shows these are completely different and created freshly. Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Step 7: Run the spring application as Java Application Output: Singleton Bean value: Pune———- Instance hashcode: 1509563803 Singleton Bean value: Pune———- Instance hashcode: 1509563803 Prototype Bean value: Pune———- Instance hashcode: 684874119 Prototype Bean value: null———- Instance hashcode: 1157740463... Read more...Spring Constructor InjectionJuly 22, 2018Spring CoreIn this example , we will see Second type of dependency injection in Spring i.e. Contructor Injection – Tools used to create below project – Spring 5.0.7.RELEASE Maven 3.3 Java 8 Eclipse Neon.2 Github Link : Download Step 1: Create Simple Maven Project with Spring Configuration Step 2: Configure maven dependencies Below pom.xml file contains the dependencies required for spring project – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringConstructorInjection</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringConstructorInjection</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.7.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!– Spring 5 dependencies –> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project> Below project structure will be created for you by Eclipse . Step 3: Create Employee.java and Address.java under com.myjavablog.beans package – Employee.java package com.myjavablog.beans; /** * @author anupb * */ public class Employee { private String name; private Address address; public Employee(String name, Address address) { super(); this.name = name; this.address = address; } public String getName() { return name; } public Address getAddress() { return address; } @Override public String toString() { return “Employee “; } } Address.java package com.myjavablog.beans; /** * @author anupb * */ public class Address { private String city; private String state; public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getState() { return state; } public void setState(String state) { this.state = state; } @Override public String toString() { return “Address “; } } These are bean files where we have only getters and setters defined. Step 4: Create ApplicationContext.xml under /src/main/resources- ApplicationContext.xml <?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:context=”http://www.springframework/schema/context” xmlns:mvc=”http://www.springframework.org/schema/mvc” xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd”> <bean id=”EmployeeBean” class=”com.myjavablog.beans.Employee”> <constructor-arg index=”0″ type=”java.lang.String” value=”Anup” /> <constructor-arg index=”1″ ref=”AddressBean” /> </bean> <bean id=”AddressBean” class=”com.myjavablog.beans.Address”> <property name=”city” value=”Pune”></property> <property name=”state” value=”Maharashtra”></property> </bean> </beans> You must have noted here that, Employee class has dependency on Address class. So Address is injected into the Employee through Dependency Injection . And as we have initialized address object through constructor in Employee class this is called Constructor Dependency Injection. Here ref=”AddressBean” is a reference to AddressBean and its injected into Employee object through Employee Constructor. Here We have declared two beans with corresponding ids. 1.Class Employee with id as “EmployeeBean” 2.Class Address with id as “AddressBean” constructor-arg tag is used for providing argument to bean’ s constructor.type is for declaring data types and index defines position in constructor’s argument. In above xml,Two arguments are passed. 1. Anup as string 2. AddressBean‘s reference to Address Object Step 5: Create a ConstructorMethodMain.java under com.myjavablog package – package com.myjavablog; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.myjavablog.beans.Address; import com.myjavablog.beans.Employee; public class ConstructorMethodMain { public static void main(String[] args) { @SuppressWarnings(“resource”) ApplicationContext beanFactory = new ClassPathXmlApplicationContext(“ApplicationContext.xml”); Employee beanInstance = (Employee) beanFactory.getBean(“EmployeeBean”); Address add = beanInstance.getAddress(); System.out.println(“Employee Name:” + beanInstance.getName() +” City: “+ add.getCity() +” State: “+add.getState()); } } We have created ApplicationContext which actually loads bean definitions from XML configuration. Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Step 7: Run the spring application as Java Application Output: Employee Name:Anup City: Pune State: Maharashtra... Read more...Spring Setter InjectionJuly 22, 2018Spring CoreIn this example , we will see first type of dependency injection in Spring i.e. Setter Injection – Tools used to create below project – Spring 5.0.7.RELEASE Maven 3.3 Java 8 Eclipse Neon.2 Github Link : Download Step 1: Create Simple Maven Project with Spring Configuration Step 2: Configure maven dependencies Below pom.xml file contains the dependencies required for spring project – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringSetterInjection</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringSetterInjection</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.7.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!– Spring 5 dependencies –> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project> Below project structure will be created for you by Eclipse . Step 3: Create Employee.java and Address.java under com.myjavablog.beans package – Employee.java /** * */ package com.myjavablog.beans; /** * @author anupb * */ public class Employee { private String name; private Address address; public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } @Override public String toString() { return “Employee “; } } Address.java /** * */ package com.myjavablog.beans; /** * @author anupb * */ public class Address { private String city; private String state; public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getState() { return state; } public void setState(String state) { this.state = state; } @Override public String toString() { return “Address “; } } These are bean files where we have getters and setters defined. Step 4: Create ApplicationContext.xml under /src/main/resources- ApplicationContext.xml <?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:context=”http://www.springframework/schema/context” xmlns:mvc=”http://www.springframework.org/schema/mvc” xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd”> <bean id=”EmployeeBean” class=”com.myjavablog.beans.Employee”> <property name=”name” value=”Anup” /> <property name=”address” ref=”AddressBean”></property> </bean> <bean id=”AddressBean” class=”com.myjavablog.beans.Address”> <property name=”city” value=”Pune” ></property> <property name=”state” value=”Maharashtra”></property> </bean> </beans> You must have noted here that, Employee class has dependency on Address class. So Address is injected into the Employee through Dependency Injection . And as we have initialized address object through setAddress() method in Employee class this is called Setter Dependency Injection. Here ref=”AddressBean” is a reference to AddressBean and its injected into Employee object. Step 5: Create a SetterMethodMain.java under com.myjavablog package – package com.myjavablog; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.myjavablog.beans.Address; import com.myjavablog.beans.Employee; public class SetterMethodMain { public static void main(String[] args) { @SuppressWarnings(“resource”) ApplicationContext beanFactory = new ClassPathXmlApplicationContext(“ApplicationContext.xml”); Employee beanInstance = (Employee) beanFactory.getBean(“EmployeeBean”); Address add = beanInstance.getAddress(); System.out.println(“Employee Name:” + beanInstance.getName() +” City: “+ add.getCity() +” State: “+add.getState()); } } We have created ApplicationContext which actually loads bean definitions from XML configuration. Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Step 7: Run the spring application as Java Application Output: Employee Name:Anup City: Pune State: Maharashtra... Read more...Spring Inversion Of Control(IOC) vs Dependency Injection(DI)July 20, 2018Spring CoreInversion Of Control (IOC) This is common characteristic of frameworks, IOC manages java objects from instantiation to destruction through its BeanFactory. Java components that are instantiated by the IoC container are called beans, and the IoC container manages a bean’s scope, lifecycle events, and any AOP features for which it has been configured and coded. Dependency Injection(DI) The basic concept of the dependency injection (also known as Inversion of Control pattern) is that you do not create your objects but describe how they should be created. You don’t directly connect your components and services together in code but describe which services are needed by which components in a configuration file. An IOC container is then responsible for hooking it all up. For example : Suppose we have an object Employee and it has a dependency on object Address. So we define a bean corresponding to Employee where it will define its dependency on object Address. When Spring tries to create an Object Employee it sees that Employee has a dependency on object Address so first it will create the Address object (dependent object) and then inject this into the Employee Object. Normal way (Without dependency Injection) – Here Employee class has dependency on address object. So we have instantiated address object in traditional way using new operator as below – With Dependency Injection – Here we have outsourced the object creation task to third party in our case it’s spring container. In spring these objects are called as beans. These beans can be configured using XML or Annotation based configuration as shown in earlier posts. Employee objects has a dependency on Address . So this dependency is injected by third party . This process is called Dependency Injection (DI). Benifits of Dependency Injection in Spring: Ensures configuration and uses of services are separate. Can switch implementations by just changing configuration. Enhances Testability as mock dependencies can be injected. Dependencies can be easily identified. How to Implement Inversion of Control In object-oriented programming, there are several basic techniques to implement inversion of control as below- Using a factory pattern Using a service locator pattern Using a dependency injection of any given below type: a constructor injection a setter injection an interface injection Constructor Injection Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator. Additionally, calling a static factory method with specific arguments to construct the bean, can be considered almost equivalent, and the rest of this text will consider arguments to a constructor and arguments to a static factory method similarly. public class ConstructorDI { DemoBean demoBean = null; public TestSetterDI (DemoBean demoBean) { this.demoBean = demoBean; } } Setter Injection Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean. public class SetterDI { DemoBean demoBean = null; public void setDemoBean(DemoBean demoBean) { this.demoBean = demoBean; } } Interface Injection In this methodology we implement an interface from the IOC framework. IOC framework will use the interface method to inject the object in the main class. It is much more appropriate to use this approach when you need to have some logic that is not applicable to place in a property. Such as logging support. public void SetLogger(ILogger logger) { _notificationService.SetLogger(logger); _productService.SetLogger(logger); }... Read more...Spring Annotation Based ConfigurationJuly 18, 2018Spring CoreIn previous post we have seen how to configure spring using XML configuration. Now in this example , we will see spring configuration using annotations – Tools used to create below project – Spring 5.0.7.RELEASE Maven 3.3 Java 8 Eclipse Neon.2 Github Link : Download Step 1: Create Simple Maven Project with Spring Configuration Step 2: Configure maven dependencies Below pom.xml file contains the dependencies required for spring project – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringAnnotationBasedConfiguration</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringAnnotationBasedConfiguration</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.7.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!– Spring 5 dependencies –> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project> Below project structure will be created for you by Eclipse . Step 3: Create City.java under com.myjavablog.beans package – package com.myjavablog.beans; /** * @author anupb * */ public class City { String cityName; public City(String cityName) { this.cityName = cityName; } public String getcityName() { return cityName; } public void setcityName(String cityName) { this.cityName = cityName; } } This is the bean file where we have getters and setters defined. Step 4: Create AnnotationConfig .java file under com.myjavablog.config package- AnnotationConfig.java /** * */ package com.myjavablog.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.myjavablog.beans.City; /** * @author anupb * */ @Configuration public class AnnotationConfig { @Bean(name=”cityObj”) public City getCountry() { return new City(“Pune”); } } This is Annotation based configuration to configure City bean. Its similar to XML based configuration which we did in previous post. The same Configuration can be done in XML as 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: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/context http://www.springframework.org/schema/context/spring-context-3.0.xsd”> <context:annotation-config/> <bean id=”countryObj” class=”org.arpit.java2blog.Country” > <property name=”countryName” value=”India”/> </bean> </beans> Step 5: Create a SpringJavaBasedConfigMain.java under com.myjavablog package – package com.myjavablog; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import com.myjavablog.beans.City; import com.myjavablog.config.AnnotationConfig; /** * Hello world! * */ public class SpringJavaBasedConfigMain { public static void main(String[] args) { @SuppressWarnings(“resource”) ApplicationContext appContext = new AnnotationConfigApplicationContext(AnnotationConfig.class); City cityObj = (City) appContext.getBean(“cityObj”); String cityName = cityObj.getcityName(); System.out.println(“City name: ” + cityName); } } We have created ApplicationContext which actually loads bean definitions from annotation configuration i.e. AnnotationConfig.java Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Step 7: Run the spring application as Java Application Output: City name: Pune... Read more...Spring Hello WorldJuly 17, 2018Spring CoreWe will create a simple HelloWorld application using spring – Tools used to create below project – Spring 5.0.7.RELEASE Maven 3.3 Java 8 Eclipse Neon.2 Github Link : Download Step 1: Go to File -> New -> Project -> Maven Project . Select maven-archetype-quickstart and click Next. Then you need to configure project name, group, artifact and package as shown below – Step 2: Configure maven dependencies Below pom.xml file contains the dependencies required for spring project – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringHelloWorld</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringHelloWorld</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.7.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <!– Spring 5 dependencies –> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project> Below project structure will be created for you by Eclipse . Step 3: Create HelloWorldBean.java under com.myjavablog.beans package – package com.myjavablog.beans; /** * Hello world! * */ public class HelloWorldBean { String name; public void printHello() { System.out.println(“Hello World from ” + name); } public String getName() { return name; } public void setName(String name) { this.name = name; } } This is the bean file where we have getters and setters defined. Step 4: Create resources folder /src/main directory – HelloWorld.xml <?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:context=”http://www.springframework/schema/context” xmlns:mvc=”http://www.springframework.org/schema/mvc” xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd”> <bean id=”HelloWorldBean” class=”com.myjavablog.beans.HelloWorldBean”> <property name=”name” value=”Anup” /> </bean> </beans> This contains XML configuration for all the beans which we need to inject into our application. Bean tag has attributes like – id = Bean ID for unique identification Class = Associate the bean class property = To initialize various attributes of the bean Step 5: Create a HelloWorldMain.java under com.myjavablog package – package com.myjavablog; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.myjavablog.beans.HelloWorldBean; /** * @author anupb * */ public class HelloWorldMain { /** * @param args */ public static void main(String[] args) { ApplicationContext beanFactory = new ClassPathXmlApplicationContext(“HelloWorld.xml”); HelloWorldBean beanInstance = (HelloWorldBean) beanFactory.getBean(“HelloWorldBean”); beanInstance.printHello(); } } We have create ApplicationContext which actually loads XML bean definitions from class path resource i.e. HelloWorld.xml Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Step 7: Run the spring application Output: Hello World from Anup... Read more...Spring IOC Container TypesJuly 16, 2018Spring CoreSpring Container Types – The Spring container is the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application. Spring mainly provides following two types of containers – BeanFactory container ApplicationContext container 1. BeanFactory container A BeanFactory is essentially nothing more than the interface for an advanced factory capable of maintaining a registry of different beans and their dependencies. The BeanFactory enables you to read bean definitions and access them using the bean factory. When using just the you would create one and read in some bean definitions in the XML format. Below are the ways to create BeanFactory – InputStream is = new FileInputStream(“beans.xml”); BeanFactory factory = new XmlBeanFactory(is); //Get bean HelloWorld obj = (HelloWorld) factory.getBean(“helloWorld”); Resource resource = new FileSystemResource(“beans.xml”); BeanFactory factory = new XmlBeanFactory(resource); //Get bean HelloWorld obj = (HelloWorld) factory.getBean(“helloWorld”); ClassPathResource resource = new ClassPathResource(“beans.xml”); BeanFactory factory = new XmlBeanFactory(resource); //Get bean HelloWorld obj = (HelloWorld) factory.getBean(“helloWorld”); 2. ApplicationContext container This container adds more enterprise-specific functionality such as the ability to resolve textual messages from a properties file and the ability to publish application events to interested event listeners. This container is defined by the org.springframework.context.ApplicationContext interface. The ApplicationContext container includes all functionality of the BeanFactory container, so it is generally recommended over the BeanFactory. BeanFactory can still be used for lightweight applications like mobile devices or applet based applications where data volume and speed is significant. The most commonly used ApplicationContext implementations are: FileSystemXmlApplicationContext: This container loads the definitions of the beans from an XML file. You need to provide the full path of the XML bean configuration file to the constructor. ClassPathXmlApplicationContext This container loads the definitions of the beans from an XML file. You do not need to provide the full path of the XML file but you need to set CLASSPATH properly because this container will look bean configuration XML file in CLASSPATH. WebXmlApplicationContext: This container loads the XML file with definitions of all beans from within a web application. A sample code for application context instantiation is as below. ApplicationContext context = new FileSystemXmlApplicationContext(“beans.xml”); HelloWorld obj = (HelloWorld) context.getBean(“helloWorld”); Cheers!!!!!!... Read more...Spring IntroductionJuly 14, 2018Spring CoreIntroduction – Spring is an open source framework created to address the complexity of enterprise application development.Spring is one of the most popular frameworks for Java enterprise edition.Spring framework was designed by Rod Johnson. Since then Spring has became alternative technology in java world for EJB model. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development . Below Spring frameworks has been released till date – On Jun 2003– Took license from Apache and First released as a Framework. Jan 2006- Won the two awards Jolt productivity award and JAX Innovation Award. On Oct 2006– Spring 2.0 released. On Nov 2007– Spring 2.5 released. On Dec 2009 – Spring 3.0 released. On Dec 2011– Spring 3.1 released. On Jun 2012– Spring 3.2 released. On December 2013– Spring 4.0 released. On 31 July 2015– Spring 4.2 released. On 10 June 2016– Spring 4.3 released. On July 28, 2016 Spring 5 released . New features introduced in Spring 5 are – JDK baseline update – JDK 1.8 or above Core framework revision. Core container updates. Functional programming with Kotlin. Reactive Programming Model. Testing improvements. Library support. Discontinued support. Features – Inversion Of Control (IOC) Basic concept of the Dependency Injection or Inversion of Control is that, we do not need to create the objects, instead just describe how it should be created. No need to directly connect your components and services together in program, instead just describe which services are needed by which components in a configuration file/xml file. The Spring IOC container is then responsible for binding it all up. Dependency Injection It is a composition of structural design patterns, in which for each function of the application there is one, a conditionally independent object (service) that can have the need to use other objects (dependencies) known to it by interfaces. Dependencies are transferred (implemented) to the service at the time of its creation. This is a situation where we introduce an element of one class into another. In practice, DI is implemented by passing parameters to the constructor or using setters. Libraries that implement this approach are also called IoC containers. Lightweight Spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 1MB. And the processing overhead is also very negligible. Container Spring container manages the life cycle and configuration of application objects. MVC Framework Spring comes with MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles and POI. But other frameworks can be easily used instead of Spring MVC Framework. Architecture – Spring Core The Core package is the most import component of the Spring Framework. This component provides the Dependency Injection features. The BeanFactory provides a factory pattern which separates the dependencies like initialization, creation and access of the objects from your actual program logic. Spring Context This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API. Spring AOP One of the key components of Spring is the AOP framework. AOP is used in Spring: To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on Spring’s transaction abstraction. To allow users to implement custom aspects, complementing their use of OOP with AOP Spring ORM The ORM package is related to the database access. It provides integration layers for popular object-relational mapping APIs, including JDO, Hibernate and iBatis. Spring Web The Spring Web module is part of Spring?s web application development stack, which includes Spring MVC. Spring DAO The DAO (Data Access Object) support in Spring is primarily for standardizing the data access work using the technologies like JDBC, Hibernate or JDO. Spring Web MVC This is the Module which provides the MVC implementations for the web applications. Spring Test This module covers the testing of Spring components with TestNG or JUnit. It balances the consistency of loading in ApplicationContexts and caching of them in Spring. Mock objects are created to test the code in isolation. ... Read more...Collections in javaJuly 1, 2018Core JavaWe will see collections in java in below posts –... Read more...HashCode and Equals methods in javaJune 30, 2018Core JavaWe will see hashcode() and equals() methods in java. These methods can be found in the Object class and hence available to all java classes.Using these two methods, an object can be stored or retrieved from a Hashtable, HashMap or HashSet. hashcode() and equals() method hashcode():You might know if you put entry in Map, first hashcode is calculated and this hashcode is used to find index of bucket where this entry will get stored in Map. If you don’t override hashcode method, it will return integer representation of memory address. equals():You have to override equals method, when you want to define equality between two object. If you don’t override this method, it will check for reference equality(==) i.e. if tow reference refers to same object or not. Lets see below example for more details – package com.myjavablog.javainterview.hashcodeandequals; public class Person { private String name; private int age;public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } Person class has two attributes name and age. How can you compare two Person objects? So here you have equals() method from Object class which you can implement in Person class. You can compare two Person objects using particular attribute either name or age from Person class . Below program will check equality for Person objects – package com.myjavablog.javainterview.hashcodeandequals; /** * @author anupb * */ public class EqualityCheck {/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stubPerson p1 = new Person(); p1.setName(“Anup”); Person p2 = new Person(); p2.setName(“Anup”);System.out.println(“Are these two persons same: ” + p1.equals(p2)); }} Output: Are these two persons same: false Here you have not implemented equals method in Person class. So above equality check happens on memory address and not on the attributes of the object. Above two objects p1 and p2 points to different memory addresses. Ideally these two Persons are same but above equality check fails. So now we will add equals() method to Person class which actually compares the objects – @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } Now lets see the output of EqualityCheck – Are these two persons same: true This is because you have overridden equals method . Now lets put these person objects into HashMap – Key is Person object Value – City name to which he belongs (String type) package com.myjavablog.javainterview.hashcodeandequals;import java.util.HashMap; import java.util.Iterator; import java.util.Map;/** * @author anupb * */ public class HashMapEqualityCheck {/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stubPerson p1 = new Person(); p1.setName(“Anup”); Person p2 = new Person(); p2.setName(“Anup”); Map<Person, String> personMap = new HashMap<>(); personMap.put(p1, “Pune”); personMap.put(p2, “Pune”); Iterator<Person> itr = personMap.keySet().iterator(); while (itr.hasNext()) { Person p = itr.next(); String city = personMap.get(p); System.out.println(“Person: ” + p.getName() + ” City: ” + city); } } } Output: Person: Anup City: Pune Person: Anup City: Pune Now you must be wondering , how HashMap contains two keys with are equal. This is because HashMap first calculates hashcode of the key. It will then calculate the bucket index in the HashMap. If two hashcodes are equal then it will use equals method to compare these two objects and because hashcode for above two person objects uses default hashcode method,Both will have different memory address hence different hashcode. Now override below hashcode method – @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } Now if you run HashMapEqualityCheck , you can see only one key will be inserted as below – Person: Anup City: Pune So now hashcode for above two objects p1 and p2 are same, so Both will be point to same bucket,now equals method will be used to compare them which will return true. So the contract says “if you override equals() method then you must override hashCode() method” hashcode() If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result. It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables. Key points to remember: If you are overriding equals method then you should override hashcode() also. If two objects are equal then they must have same hashcode. If two objects have same hashcode then they may or may not be equal Always use same attributes to generate equals and hashcode as in our case we have used name.... Read more...3. Hello World JavaJune 30, 2018Core JavaYou can either write a program in IDE such eclipse , IntelliJ IDEA or you can simply write in in text editor. <java> </java>... Read more...2. Java Environment SetupJune 30, 2018Core JavaJava is platform independent i.e. when you write the program and compile it . Then compiler will generate bytecode i.e. .class file . This bytecode can run on any Java virtual machine (JVM) regardless of computer architecture. You should know below things before setting the java environment – JDK(Java Development Kit) : JDK is intended for software developers and includes development tools such as the Java compiler, Javadoc, Jar, and a debugger. JRE(Java Runtime Environment) : JRE contains the parts of the Java libraries required to run Java programs and is intended for end users. JRE can be view as a subset of JDK. JVM: JVM (Java Virtual Machine) is an abstract machine. It is a specification that provides runtime environment in which java bytecode can be executed. JVMs are available for many hardware and software platforms. Steps to install java and setting java path variables – Download Java8 JDK is available at Download Java 8. 2. Install java by clicling on .exe file and after that you need to setup java environment variables. 3. Go to Control Panel -> System and Security -> System -> Environment variables as highlighted below – 4. In java 8 on windows 10 , it creates a symbolic link to java environment automatically under path highlighted below – So no need to set java path externally . In windows 7 , you can save the path as below – Set JAVA_HOME and add this variable in path system variables. 5. You are ready to use java now. Check if java is installed by firing java –version command on command line. ... Read more...Java BasicsJune 30, 2018Core JavaBasics of java... Read more...1 Introduction to JavaJune 30, 2018Core JavaHistory of Java: Java programming language was developed by James Ghosling, Patrick Naughton, Mike Sheridan at Sun Microsystems Inc. in 1991. The initial name was Oak but it was renamed to Java in 1995 as OAK was a registered trademark of another Tech company. Evolution of Java: Current stable release of Java is Java SE 8 and development of Java SE 9 is in progress and will be released soon. Below are the versions that have been released – JDK Alpha and Beta (1995) JDK 1.0 (23rd Jan, 1996) JDK 1.1 (19th Feb, 1997) J2SE 1.2 (8th Dec, 1998) J2SE 1.3 (8th May, 2000) J2SE 1.4 (6th Feb, 2002) J2SE 5.0 (30th Sep, 2004): This version of Java have introduced major changes in java programming world. Some of them are: Java Concurrency API Var argument methods Generics Annotations For each loop Enumerations Static import Autoboxing and unboxing etc. Java SE 6 (11th Dec, 2006) Java SE 7 (28th July, 2011) : Java 7 has following new major changes: Multi-catch block Support of String in Switch case Try with resources etc. Java SE 8 (18th March, 2014) : Java 8 has introduced major programming paradigms. Some of them are: Lambda Expressions. Functional Interfaces Default methods in interface. Streams Enhanced Security etc Features of Java: Java is a general-purpose computer programming language that is concurrent, class-based, object-oriented etc. Platform independence: Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of computer architecture. Java is write-once, run-anywhere language. Once you compile java code, you can run it on any machine. For example: If you compile your code on Windows OS, you can easily run the same bytecode in linux. Simple: Java is easy to learn. It does not include concepts of pointers and operator overloading that were available in C++. Object Oriented: You can model everything into an object which has data and behavior. Java has incorporated various object-oriented concepts such as Abstraction, Encapsulation, Polymorphism, Modularization and inheritance. Portable: Java byte can be portable to any platform and can be executed on any platform. Multi-threading: Java has provided multithreading feature which will help you to execute various task in parallel. It has introduced executor framework which is more robust and easy to use. High performance: Java can not be as fast as C and C++ as it is interpreted language but it has provided various features such as Just in time compiler to increase performance. I think You might have got some idea about Java now.... Read more...Interview QuestionsJune 30, 2018InterviewJava is one of the most popular programming language. There is a growing demand for Java Developer jobs in technology companies. This tutorial will cover most of the topics from Java Technology and related topics like Spring, Hibernate, Maven, Git, Microservices, AWS etc I have compiled this list after attending dozens of technical interviews in top-notch companies like UBS, Deutsche bank, BNY Mellon, Credit Suisse, HSBC,Northen Trust, Congnizant, Infosys , TCS, Wipro etc. Each question is accompanied with an answer so that you can prepare for job interview in a very short time. Please find below posts – Spring Data JPA and Hibernate Interview Questions Java Interview Questions Collections Interview questions Immutable Class in Java... Read more...Spring Boot + ActiveMQJune 29, 2018Spring BootWe will use Spring boot with ActiveMQ as below – Github Link: Download We can connect to in memory or message queue hosted on external server – Tools used for below project – Spring Boot 2.0.3.RELEASE Spring 5.0.7.RELEASE ActiveMQ Embeded 8 Maven 3.3 Java 8 Spring Tool Suite IDE (STS) Step 1: Project Structure Step 2: Create a project named SpringBootMessageQueue in STS (Refer Create new project in STS). Additionally select JMS(ActiveMQ) dependency from starter project dependencies popup – Step 3: Below pom.xml will be generated for you by STS . <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.anup.springboot</groupId> <artifactId>Springboot_HelloWorld</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>Springboot_HelloWorld Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.3.RELEASE</version> <relativePath /> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> <finalName>Springboot_HelloWorld</finalName> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a spring boot application , we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-activemq for connecting to ActiveMQ. Let’s do ActiveMQ configuration first. Application Properties- Step 4: Update“Application.properties” file under /src/main/resources folder to create in memory MQ – spring.activemq.in-memory=true spring.activemq.pool.enabled=false If you want to use activemq hosted on external server then you need to do configuration as below – spring.activemq.broker–url=tcp://localhost:61616 Spring boot main file Step 5: “SpringBootApplicatioMain.java” file must be created under com.myjavablog package by STS package com.anup.springboot; import javax.jms.Queue; import org.apache.activemq.command.ActiveMQQueue; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; import org.springframework.jms.annotation.EnableJms; @SpringBootApplication @EnableJms public class SpringBootApplicatioMain { public static void main(String[] args) { SpringApplication.run(SpringBootApplicatioMain.class, args); } @Bean public Queue queue() { return new ActiveMQQueue(“com.anup.testqueue”); } } This is the main file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work. Let’s understand more about this annotation. @SpringBootApplication is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application context. @EnableAutoConfiguration – It enables Spring boot to add beans presents in classpath setting and various property setting. Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet. @ComponentScan – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers. @EnableJMS annotation is used to trigger search for method annotated with @JMSListener, hence to create JMS listener in the background. If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Step 6: Create a file named “WebSecurityConfiguaration.java” in package com.myjavablog /** * */ package com.myjavablog; /** * @author anupb * */ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.crypto.password.NoOpPasswordEncoder; @Configuration @EnableWebSecurity public class WebSecurityConfiguaration extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin(); } @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication().passwordEncoder(NoOpPasswordEncoder.getInstance()). withUser(“myjavablog”).password(“secure”).roles(“ADMIN”); } } @EnableWebSecurity – Enables security for our application. http.authorizeRequests().antMatchers(“/hello*”) – Secures all the URLs containing hello word in it. http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin() – Allows role based access to these URLs . User with only admin can access this URL. auth.inMemoryAuthentication().withUser(“myjavablog”).password(“secure”).roles(“ADMIN”) – We are using in Memory authentication to authenticate the user. User credentials are stored in memory for this example. We can store them either in database , LDAP etc. When user provides myjavablog/secure credentials in login form then only he can access URLs with /hello as this user has ADMIN role. Run the application Step 10: Right Click on Project -> Debug As -> Maven Build Step 8: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 9: Now once you run the application, spring boot will create a Queue in a memory and puts the messages onto that queue as below – . ____ _ __ _ _ /\\ / ___’_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | ‘_ | ‘_| | ‘_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ‘ |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.5.3.RELEASE) 2018-06-24 21:14:27.007 INFO 17356 — c.a.springboot.SpringBootApplicatioMain : Starting SpringBootApplicatioMain on DESKTOP-IK4A0TS with PID 17356 (started by anupb in E:\Study Material\Software Setups\UI\STS_Wksp\SpringBootMessageQueue) 2018-06-24 21:14:27.034 INFO 17356 — c.a.springboot.SpringBootApplicatioMain : No active profile set, falling back to default profiles: default 2018-06-24 21:14:27.307 INFO 17356 — s.c.a.AnnotationConfigApplicationContext : Refreshing org.spring[email protected]514646ef: startup date ; root of context hierarchy 2018-06-24 21:14:29.976 INFO 17356 — o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup 2018-06-24 21:14:29.989 INFO 17356 — o.s.c.support.DefaultLifecycleProcessor : Starting beans in phase 2147483647 2018-06-24 21:14:30.127 WARN 17356 — o.apache.activemq.broker.BrokerService : Memory Usage for the Broker (1024mb) is more than the maximum available for the JVM: 889 mb – resetting to 70% of maximum available: 622 mb 2018-06-24 21:14:30.422 INFO 17356 — o.apache.activemq.broker.BrokerService : Using Persistence Adapter: MemoryPersistenceAdapter 2018-06-24 21:14:30.618 INFO 17356 — o.a.a.broker.jmx.ManagementContext : JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi 2018-06-24 21:14:30.675 INFO 17356 — o.apache.activemq.broker.BrokerService : Apache ActiveMQ 5.14.5 (localhost, ID:DESKTOP-IK4A0TS-57046-1529855070442-0:1) is starting 2018-06-24 21:14:30.687 INFO 17356 — o.apache.activemq.broker.BrokerService : Apache ActiveMQ 5.14.5 (localhost, ID:DESKTOP-IK4A0TS-57046-1529855070442-0:1) started 2018-06-24 21:14:30.688 INFO 17356 — o.apache.activemq.broker.BrokerService : For help or more information please see: http://activemq.apache.org 2018-06-24 21:14:30.819 INFO 17356 — o.a.activemq.broker.TransportConnector : Connector vm://localhost started Message has been put to queue by sender 2018-06-24 21:14:31.279 INFO 17356 — c.a.springboot.SpringBootApplicatioMain : Started SpringBootApplicatioMain in 5.127 seconds (JVM running for 10.015) ... Read more...Spring boot Data JPA+ Angular JS + MySQL Database CRUDJune 29, 2018Spring Boot / Spring Data JPAGithub Link: Download We are using Spring boot version 2.0.0.RELEASE . We will be creating simple TodoManager application using which we can manage our daily todo tasks. We will be using angular for front end. It will provide user interface from which you can add, update or delete tasks in todo list.We will use controller, JpaRepository classes to achieve these functionalities.We will connect to MySQL database using SessionFactory class of hibernate. Tools used for below project – Spring Boot 2.0.0.RELEASESpring 5.0.4.RELEASETomcat Embed 8Maven 3.3Java 8Spring Tool Suite IDE (STS)Spring Data JPA 2.0.5.RELEASEMySql 5.1.21 Step 1: Project Structure Step 2: Create a project named TodoListManagerJPA in STS (Refer Create new project in STS) Step 3: Change pom.xml as below – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.anup.springboot</groupId> <artifactId>TodoListManagerJPA</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>Springboot JPA Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.0.RELEASE</version> <relativePath /> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!– mySQL DB –> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> <!– <plugin> <artifactId>maven-war-plugin</artifactId> <version>2.6</version> <configuration> <failOnMissingWebXml>false</failOnMissingWebXml> </configuration> </plugin> –> </plugins> <finalName>TodoListManagerJPA</finalName> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a web application, we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-data-jpa to run this application with MySQL database.You need to also put mysql-connector-java for MySql JDBC driver.If you are using any other database, you need to use different database connector.Let’s do hibernate configuration first. Step 4: Create a “application.properties” file in package /src/main/resources spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8081 ## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties) spring.datasource.url = jdbc:mysql://localhost:3306/test?useSSL=false spring.datasource.username = root spring.datasource.password = root ## Hibernate Properties # The SQL dialect makes Hibernate generate better SQL for the chosen database spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect # Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto = update In the above properties file, the last two properties are for hibernate. Spring Boot uses Hibernate as the default JPA implementation. The property spring.jpa.hibernate.ddl-auto is used for database initialization. I’ve used the value “update”for this property. It does two things – When you define a domain model, a table will automatically be created in the database and the fields of the domain model will be mapped to the corresponding columns in the table.Any change to the domain model will also trigger an update to the table. For example, If you change the name or type of a field, or add another field to the model, then all these changes will be reflected in the mapped table as well. Using update for spring.jpa.hibernate.ddl-auto property is fine for development. But, For production, You should keep the value of this property to “validate”, and use a database migration tool like Flyway for managing changes in the database schema. Step 5: Create a “Task.java” model class in com.myjavablog.springboot.pojo package package com.myjavablog.springboot.pojo; import java.io.Serializable; import java.util.Date; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.EntityListeners; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; import javax.persistence.Temporal; import javax.persistence.TemporalType; import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.LastModifiedDate; import org.springframework.data.jpa.domain.support.AuditingEntityListener; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; /** * @author anup * */ @Entity @Table(name=”TASKS”) @EntityListeners(AuditingEntityListener.class) @JsonIgnoreProperties(value = {“createdAt”, “updatedAt”}, allowGetters = true) public class Task implements Serializable { /** * */ private static final long serialVersionUID = 1L; @Id @Column(name=”ID”) @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name=”TASK_NAME”) private String taskName; @Column(name=”TASK_DESC”) private String taskDesc; @Column(name=”STATUS”) private String status; @Column(nullable = false, updatable = false , name= “CREATED_AT”) @Temporal(TemporalType.TIMESTAMP) @CreatedDate private Date createdAt; @Column(nullable = false, name= “UPDATED_AT”) @Temporal(TemporalType.TIMESTAMP) @LastModifiedDate private Date updatedAt; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getTaskName() { return taskName; } public void setTaskName(String taskName) { this.taskName = taskName; } public String getTaskDesc() { return taskDesc; } public void setTaskDesc(String taskDesc) { this.taskDesc = taskDesc; } public String getStatus() { return status; } public void setStatus(String status) { this.status = status; } public Date getCreatedAt() { return createdAt; } public void setCreatedAt(Date createdAt) { this.createdAt = createdAt; } public Date getUpdatedAt() { return updatedAt; } public void setUpdatedAt(Date updatedAt) { this.updatedAt = updatedAt; } } @Entity – This marks class as Entity @Table – This maps class to database table @Id – Marks the class variable as primary key column in table @Column – Marks it as a column in table , we can also configure name attribute defining its name in database table @Temporal – annotation is used with java.util.Dateand java.util.Calendar classes. It converts the date and time values from Java Object to compatible database type and vice versa. @JsonIgnoreProperties – annotation is a Jackson annotation. Spring Boot uses Jackson for Serializing and Deserializing Java objects to and from JSON.This annotation is used because we don’t want the clients of the rest api to supply the createdAt and updatedAt values. If they supply these values then we’ll simply ignore them. However, we’ll include these values in the JSON response. @EntityListeners(AuditingEntityListener.class) – In our Task model we have annotated createdAt and updatedAt fields with @CreatedDate and @LastModifiedDate annotations respectively. Now, what we want is that these fields should automatically get populated whenever we create or update an entity. To achieve this, we need to do two things – Add Spring Data JPA’s AuditingEntityListener to the domain model. We have already done this in our Task model with the annotation @EntityListeners(AuditingEntityListener.class). Enable JPA Auditing in the main application. Open TodoManagerApplication.java and add @EnableJpaAuditing annotation. @GeneratedValue – Marking a field with the @GeneratedValue annotation specifies that a value will be automatically generated for that field. This is primarily intended for primary key fields .There are below types of strategies – GenerationType.AUTO – It is the default generation type and lets the persistence provider choose the generation strategy. @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.IDENTITY – The GenerationType.IDENTITY is the easiest to use but not the best one from a performance point of view. It relies on an auto-incremented database column and lets the database generate a new value with each insert operation. From a database point of view, this is very efficient because the auto-increment columns are highly optimized, and it doesn’t require any additional statements. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.SEQUENCE – The GenerationType.SEQUENCE is my preferred way to generate primary key values and uses a database sequence to generate unique values. If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) @Column(name = “id”, updatable = false, nullable = false) private Long id; You can change that by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation. The @SequenceGenerator annotation lets you define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence. @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = “book_generator”) @SequenceGenerator(name=”book_generator”, sequenceName = “book_seq”, allocationSize=50) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.TABLE – The GenerationType.TABLE gets only rarely used nowadays. It simulates a sequence by storing and updating its current value in a database table which requires the use of pessimistic locks which put all transactions into a sequential order. This slows down your application, and you should, therefore, prefer the GenerationType.SEQUENCE, if your database supports sequences, which most popular databases do If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.TABLE) @Column(name = “id”, updatable = false, nullable = false) private Long id; Summary: AUTO: Hibernate selects the generation strategy based on the used dialect,IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key,SEQUENCE: Hibernate requests the primary key value from a database sequence,TABLE: Hibernate uses a database table to simulate a sequence. Step 6: Create database tables create schema test; create table TASKS (id bigint NOT NULL AUTO_INCREMENT, TASK_NAME varchar(255), TASK_DESC varchar(255), STATUS varchar(255) , CREATED_AT timestamp, UPDATED_AT timestamp, primary key (id)); INSERT INTO TASKS VALUES(1, ‘Bath’, ‘Have a bath’ , ‘PENDING’, SYSDATE, SYSDATE); INSERT INTO TASKS VALUES(2, ‘Snacks’, ‘Have snacks’ , ‘PENDING’ , CURTIME() , CURTIME()); INSERT INTO TASKS VALUES(3, ‘Office’, ‘Office’ , ‘PENDING’ , CURTIME() , CURTIME()); INSERT INTO TASKS VALUES(4, ‘Lunch’, ‘Lunch’ , ‘PENDING’ , CURTIME() , CURTIME()); Controller class Step 7: Create class “TodoController.java” in package com.myjavablog.springboot.controller /** * */ package com.myjavablog.springboot.controller; import java.util.List; import javax.validation.Valid; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import com.myjavablog.springboot.exception.ResourceNotFoundException; import com.myjavablog.springboot.pojo.Task; import com.myjavablog.springboot.repository.TodoRepository; /** * @author anup * */ @RestController public class TodoController { @Autowired TodoRepository todoRepository; @PostMapping(value = “/todos/addTodo”) public Task addTodo(@Valid @RequestBody Task task) { return todoRepository.save(task); } @PutMapping(value = “/todos/updateTodo”) public Task updateTodo(@Valid @RequestBody Task task) { Task todo = todoRepository.findById(task.getId()) .orElseThrow(() -> new ResourceNotFoundException(“Todo”, “id”, task.getId())); todo.setStatus(task.getStatus()); todo.setTaskDesc(task.getTaskDesc()); todo.setTaskName(task.getTaskName()); Task updatedTask = todoRepository.save(todo); return updatedTask; } @GetMapping(value = “/todos/getAllTodos”) public List<Task> getAllTodos() { return todoRepository.findAll(); } @DeleteMapping(value=”/todos/deleteTodo/{id}”) public ResponseEntity<?> deleteCust(@PathVariable Long id) { todoRepository.deleteById(id); return ResponseEntity.ok().build(); } } @RestController annotation is a combination of Spring’s @Controller and @ResponseBody annotations. Repository Step 8: Create interface “TodoRepository.java” in package “com.myjavablog.springboot.repository” and extend it from JpaRepository. We have to create a repository to access Tasks from the database. Well, Spring Data JPA comes to rescue us here. It comes with a JpaRepository interface which defines methods for all the CRUD operations on the entity, and a default implementation of JpaRepository called SimpleJpaRepository. JPA has eliminated lot of boilerplate code which we need to write for CRUD operations otherwise. package com.myjavablog.springboot.repository; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import com.myjavablog.springboot.pojo.Task; /** * @author anupb * */ @Repository public interface TodoRepository extends JpaRepository<Task, Long>{ } we have annotated the interface with @Repository annotation. This tells Spring to bootstrap the repository during component scan. Cool! That is all you have to do in the repository layer. You will now be able to use JpaRepository’s methods like save(), findOne(), findAll(), count(), delete() etc. Custom Exception Step 9: Create “ResourceNotFoundException.java” in “com.myjavablog.springboot.exception” package – We have defined the Rest APIs for creating, retrieving, updating, and deleting a Task . The APIs will throw a ResourceNotFoundException whenever a Task with a given id is not found in the database. package com.myjavablog.springboot.exception; import org.springframework.web.bind.annotation.ResponseStatus; import org.springframework.http.HttpStatus; /** * @author anupb * */ @ResponseStatus(value = HttpStatus.NOT_FOUND) public class ResourceNotFoundException extends RuntimeException { private String resourceName; private String fieldName; private Object fieldValue; public ResourceNotFoundException(String resourceName, String fieldName, Object fieldValue) { super(String.format(“%s not found with %s : ‘%s'”, resourceName, fieldName, fieldValue)); this.resourceName = resourceName; this.fieldName = fieldName; this.fieldValue = fieldValue; } public String getResourceName() { return resourceName; } public String getFieldName() { return fieldName; } public Object getFieldValue() { return fieldValue; } } AngularJS UI Layer Step 10: Create “index.jsp” under \src\main\webapp\WEB-INF\views\ <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″ pageEncoding=”ISO-8859-1″%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <%@ taglib uri=”http://java.sun.com/jsp/jstl/core” prefix=”c”%> <%@ taglib uri=”http://www.springframework.org/tags” prefix=”spring”%> <%@ taglib uri=”http://www.springframework.org/tags/form” prefix=”form”%> <html> <head> <link href=”/css/app.css” rel=”stylesheet”/> <script src=”https://ajax.googleapis.com/ajax/libs/angularjs/1.4.4/angular.js”></script> <script type=”text/javascript” src=”/js/app.js”></script> <meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″> <title>Todo Manager</title> </head> <body ng-app=”todoManager” ng-controller=”todoController”> </br> <h4 class=”todo”>Todo Manager</h4> <form ng-submit=”submitTodo()”> <table> <tr> <th colspan=”2″>Add/Edit todo</th> </tr> <tr> <td>Task Name</td> <td><input type=”text” ng-model=”todoForm.taskName” /></td> </tr> <tr> <td>Task Desc</td> <td><input type=”text” ng-model=”todoForm.taskDesc” /></td> </tr> <tr> <td>Status</td> <td><select id=”status” ng-model=”todoForm.status” ng-options=”x for x in status” /></select></td> </tr> <tr> <td colspan=”2″><input type=”submit” value=”Submit” class=”blue-button” /></td> </tr> </table> </form> <table> <tr> <th width=”120″>Task Name</th> <th width=”120″>Task Desc</th> <th width=”60″>Status</th> <th width=”60″>Operations</th> </tr> <tr ng-repeat=”todo in todos” ng-init=”statusCls=getClass(todo)”> <td>{{ todo.taskName }}</td> <td>{{ todo.taskDesc }}</td> <td class=”statusCls”> {{ todo.status }} </td> <td><a ng-click=”editTodo(todo)” class=”blue-button”>Edit</a> | <a ng-click=”deleteTodo(todo)” class=”red-button”>Delete</a></td> </tr> </table> </body> </html> Step 11: Create javascript file “app.js” under \src\main\resources\static\js\ var app = angular.module(“todoManager” , []); app.controller(“todoController” , function($scope, $http){ $scope.todos = []; $scope.status = ; $scope.todoForm = { id : -1, taskName : “”, taskDesc : “” }; $scope.getClass = function(todo){ if(todo.status == ‘PENDING’) return ‘red’; else if(todo.status == ‘COMPLETED’){ return ‘green’; } } _refreshTodoData(); function _refreshTodoData(){ $http({ method : ‘GET’, url : ‘http://localhost:8082/todos/getAllTodos’ }).then(function successCallback(response) { $scope.todos = response.data; //alert($scope.todos); }, function errorCallback(response) { console.log(response.statusText); }); } $scope.submitTodo = function() { var method = “”; var url = “”; if ($scope.todoForm.id == -1) { //Id is absent in form data, it is create new todo operation method = “POST”; url = ‘/todos/addTodo’; } else { //Id is present in form data, it is edit todo operation method = “PUT”; url = ‘/todos/updateTodo’; } $http({ method : method, url : url, data : angular.toJson($scope.todoForm), headers : { ‘Content-Type’ : ‘application/json’ } }).then( _success, _error ); }; $scope.deleteTodo = function(todo) { $http({ method : ‘DELETE’, url : ‘/todos/deleteTodo/’ + todo.id }).then(_success, _error); }; $scope.editTodo = function(todo) { $scope.todoForm.taskName = todo.taskName; $scope.todoForm.taskDesc = todo.taskDesc; $scope.todoForm.status = todo.status; $scope.todoForm.id = todo.id; }; function _success(response) { //alert(“success”); _refreshTodoData(); _clearFormData(); } function _error(response) { //alert(“error”); console.log(response.statusText); } //Clear the form function _clearFormData() { $scope.todoForm.id = -1; $scope.todoForm.taskName = “”; $scope.todoForm.taskDesc = “”; $scope.todoForm.status = “”; }; }); Step 12: Create CSS file “app.css” under \src\main\resources\static\css\ for adding style .blue-button { background: #25A6E1; filter: progid: DXImageTransform.Microsoft.gradient( startColorstr=’#25A6E1′, endColorstr=’#188BC0′, GradientType=0); padding: 3px 5px; color: #fff; font-family: ‘Helvetica Neue’, sans-serif; font-size: 12px; border-radius: 2px; -moz-border-radius: 2px; -webkit-border-radius: 4px; border: 1px solid #1A87B9; cursor: pointer; } .red-button { background: #CD5C5C; padding: 3px 5px; color: #fff; font-family: ‘Helvetica Neue’, sans-serif; font-size: 12px; border-radius: 2px; -moz-border-radius: 2px; -webkit-border-radius: 4px; border: 1px solid #CD5C5C; cursor: pointer; } table { font-family: “Helvetica Neue”, Helvetica, sans-serif; width: 50%; } caption { text-align: left; color: silver; font-weight: bold; text-transform: uppercase; padding: 5px; } th { background: SteelBlue; color: white; } tbody tr:nth-child(even) { background: WhiteSmoke; } tbody tr td:nth-child(2) { text-align: center; } tbody tr td:nth-child(3), tbody tr td:nth-child(4) { text-align: center; font-family: monospace; } tfoot { background: SeaGreen; color: white; text-align: right; } tfoot tr th:last-child { font-family: monospace; } td, th { border: 1px solid gray; width: 25%; text-align: left; padding: 5px 10px; } #status{ width: 53%; padding: 1px 0; } .todo { font-size: 24px; color: #CD5C5C; text-transform: uppercase; font-family: arial; width: 50%; background: #ccc; text-align: center; border-radius: 4px; margin: 2% 0%; padding: 3px 0; box-shadow: 0px 1px 7px 1px grey; } .pending{ color: red; } .completed{ color: green; } $http – It’s used to make AJAX calls to server in order to submitTodo(), deleteTodo() , editTodo() task.When you click on submit button on form, it actually calls POST or PUT depending on operation. If you click on edit and submit data then it will be PUT operation as it will update existing resource. If you directly submit data, then it will be POST operation to create new resource.Every time you submit data, it calls _refreshTodoData() to refresh Todo table below.When you call $http, you need to pass method type and URL, it will call it according, You can either put absolute URL or relative URL with respect to context root of web application. Spring boot main file Step 13: Create “TodoManagerApplication.java” a main spring file under com.anup.springboot package com.myjavablog.springboot; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.data.jpa.repository.config.EnableJpaAuditing; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; @SpringBootApplication @EnableJpaAuditing @EnableJpaRepositories(basePackages=”com.myjavablog.springboot.repository”) public class TodoManagerApplication { public static void main(String[] args) { SpringApplication.run(TodoManagerApplication.class, args); } } This is the mail file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work.Let’s understand more about this [email protected] is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application [email protected] – It enables Spring boot to add beans presents in classpath setting and various property setting.Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath.This flags the application as a web application and activates key behaviors such as setting up a [email protected] – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers.If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Run the application Step 14: Right Click on Project -> Debug As -> Maven Build Step 15: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 16: Now once the application is up and running, you can access it from below link – Adding new task – Editing the task – Deleting the task – Now we will try to update Task which is not present in database. It should throw a custom exception and we will get response as shown below –... Read more...Spring boot + Spring SecurityJune 29, 2018Spring BootWe will use Spring boot with spring security as below – Github Link: Download We can secure spring application using spring security API provided by spring – Tools used for below project – Spring Boot 2.0.3.RELEASESpring 5.0.7.RELEASETomcat Embed 8Maven 3.3Java 8Spring Tool Suite IDE (STS) Step 1: Project Structure Step 2: Create a project named SpringBootSpringSecurityDemo in STS (Refer Create new project in STS). Select web , security dependency from starter project dependencies popup – Step 3: Below pom.xml will be generated for you by STS . You need to add JSTL and Embeded tomcat dependency if it’s not present. <?xml version=”1.0″ encoding=”UTF-8″?> <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringBootSpringSecurityDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringBootSpringSecurityDemo</name> <description>Demo project for Spring Boot with spring security</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> <relativePath /> <!– lookup parent from repository –> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!– https://mvnrepository.com/artifact/org.threeten/threetenbp –> <dependency> <groupId>org.threeten</groupId> <artifactId>threetenbp</artifactId> <version>0.7.2</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a web application, we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-security to provide security to this web application.Let’s do security configuration first. Conroller class- Step 4: Create “HelloController .java” file under com.myjavablog.controller package – package com.myjavablog.controller; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping; /** * @author anupb * */ @Controller public class HelloController { @GetMapping(“/hello”) public String getHomePage(Model model) { model.addAttribute(“message”, “Lets make our app secure”); return “hello”; } } Its a simple controller with only hello method inside it. Below are the annotations used- @Controller – @Controller is used to mark classes as Spring MVC Controller. @GetMapping – This anootation is used map GET requests from browser to java methods. If you run the application at this stage , spring boot will bootstrap spring security and default security will be provided. If you run the application and try to access http://localhost:8081/hello . This request will be intercepted by Spring security and will be redirected to login page as below – Login with default username : user and password generated by spring in below logs – Spring boot main file to bootstrap application – Step 5: Create a “SpringBootSpringSecurityDemoApplication.java” file in package com.myjavablog package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringBootSpringSecurityDemoApplication { public static void main(String[] args) { SpringApplication.run(SpringBootSpringSecurityDemoApplication.class, args); } } This is the main file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work.Let’s understand more about this [email protected] is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application [email protected] – It enables Spring boot to add beans presents in classpath setting and various property setting.Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath.This flags the application as a web application and activates key behaviors such as setting up a [email protected] – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers.If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Step 6: Create a file named “WebSecurityConfiguaration.java” in package com.myjavablog /** * */ package com.myjavablog; /** * @author anupb * */ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.crypto.password.NoOpPasswordEncoder; @Configuration @EnableWebSecurity public class WebSecurityConfiguaration extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin(); } @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication().passwordEncoder(NoOpPasswordEncoder.getInstance()). withUser(“myjavablog”).password(“secure”).roles(“ADMIN”); } } @EnableWebSecurity – Enables security for our application. http.authorizeRequests().antMatchers(“/hello*”) – Secures all the URLs containing hello word in it. http.authorizeRequests().antMatchers(“/hello*”).access(“hasRole(‘ROLE_ADMIN’)”).and().formLogin() – Allows role based access to these URLs . User with only admin can access this URL. auth.inMemoryAuthentication().withUser(“myjavablog”).password(“secure”).roles(“ADMIN”) – We are using in Memory authentication to authenticate the user. User credentials are stored in memory for this example. We can store them either in database , LDAP etc. When user provides myjavablog/secure credentials in login form then only he can access URLs with /hello as this user has ADMIN role. Step 7: Now create application.properties file inside /src/main/resources folder. spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8081 This is simillar to dispatcher servlet in spring MVC to configure view resolution. Step 8: Create index.jsp inside webapp <%@ page language=”java” contentType=”text/html; charset=UTF-8″ pageEncoding=”UTF-8″%> <%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core”%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <html> <head> <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″> <title>HelloWorld</title> </head> <body> <a href=”hello.html”>Click here to read hello message </a> </br> <a href=”<c:url value=”/logout” />”>Logout</a> </body> </html> Step 9: Create hello.jsp inside webapp/WEB-INF/views <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″ pageEncoding=”ISO-8859-1″%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <html> <head> <meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″> <title>Hello world Page</title> </head> <body> ${message} </body> </html> Run the application Step 10: Right Click on Project -> Debug As -> Maven Build Step 8: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 9: Now go to URL http://localhost:8082/. Index page will open up as below – Once you click on the link, this request will be intercepted by spring security and you will be asked to enter username and password. Home Page –... Read more...Restful webservices using Spring bootJune 29, 2018Spring BootGithub Link: Download We are using Spring boot version 1.5.9.RELEASE . We will be creating simple Todo Manager application which provides endpoints to expose todo tasks data without using any database. Spring boot makes it very easy to develop REST API . We don’t need to worry for JSON conversion using jackson–databind jar as earlier. Spring boot provides JSON dependency by default for us. Tools used for below project – Spring Boot 2.0.2.RELEASE Spring 5.0.6.RELEASE Tomcat Embed 8 Maven 3.3 Java 8 Spring Tool Suite IDE (STS) Step 1: Project Structure Step 2: Create a project named SpringBootRestful in STS (Refer Create new project in STS) Step 3: Change pom.xml as below – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.anup.springboot</groupId> <artifactId>TodoListManager</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>TodoListManager Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!– https://mvnrepository.com/artifact/org.threeten/threetenbp –> <dependency> <groupId>org.threeten</groupId> <artifactId>threetenbp</artifactId> <version>0.7.2</version> </dependency> <!– <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> </dependency> –> <!– H2 Database <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency>–> <!– mySQL DB –> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> <finalName>TodoListManager</finalName> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a web application, we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-data-jpa to run this application with hibernate.You need to also put mysql-connector-java for MySql JDBC driver.If you are using any other database, you need to use different database connector. Let’s do hibernate configuration first. Model class – Step 4: Create a “Todo.java” model class in com.anup.springboot.pojo package package com.anup.springboot.pojo; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; /** * @author anup * */ @Entity @Table(name = “TODO”) public class Todo implements Serializable { public Todo() { super(); } public Todo(Long id, String taskName, String taskDesc, String status) { super(); this.id = id; this.taskName = taskName; this.taskDesc = taskDesc; this.status = status; } @Id @Column(name = “ID”) @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = “TASK_NAME”) private String taskName; @Column(name = “TASK_DESC”) private String taskDesc; @Column(name = “STATUS”) private String status; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getTaskName() { return taskName; } public void setTaskName(String taskName) { this.taskName = taskName; } public String getTaskDesc() { return taskDesc; } public void setTaskDesc(String taskDesc) { this.taskDesc = taskDesc; } public String getStatus() { return status; } public void setStatus(String status) { this.status = status; } } @Entity – This marks class as Entity @Table – This maps class to database table @Id – Marks the class variable as primary key column in table @Column – Marks it as a column in table , we can also configure name attribute defining its name in database table @GeneratedValue – Marking a field with the @GeneratedValue annotation specifies that a value will be automatically generated for that field. This is primarily intended for primary key fields .There are below types of strategies – GenerationType.AUTO – It is the default generation type and lets the persistence provider choose the generation strategy. @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.IDENTITY – The GenerationType.IDENTITY is the easiest to use but not the best one from a performance point of view. It relies on an auto-incremented database column and lets the database generate a new value with each insert operation. From a database point of view, this is very efficient because the auto-increment columns are highly optimized, and it doesn’t require any additional statements. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.SEQUENCE – The GenerationType.SEQUENCE is my preferred way to generate primary key values and uses a database sequence to generate unique values. If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) @Column(name = “id”, updatable = false, nullable = false) private Long id; You can change that by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation. The @SequenceGenerator annotation lets you define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence. @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = “book_generator”) @SequenceGenerator(name=”book_generator”, sequenceName = “book_seq”, allocationSize=50) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.TABLE – The GenerationType.TABLE gets only rarely used nowadays. It simulates a sequence by storing and updating its current value in a database table which requires the use of pessimistic locks which put all transactions into a sequential order. This slows down your application, and you should, therefore, prefer the GenerationType.SEQUENCE, if your database supports sequences, which most popular databases do If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.TABLE) @Column(name = “id”, updatable = false, nullable = false) private Long id; Summary: AUTO: Hibernate selects the generation strategy based on the used dialect, IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key, SEQUENCE: Hibernate requests the primary key value from a database sequence, TABLE: Hibernate uses a database table to simulate a sequence. Conroller class- Step 5: Create “TodoController .java” file under com.myjavablog.controller package – /** * */ package com.myjavablog.controller; import java.util.ArrayList; import java.util.List; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import com.myjavablog.model.Task; /** * @author anupb * */ @RestController public class TodoController { static List<Task> taskList = new ArrayList<Task>(); static { Task t1 = new Task(1l, “Walking”, “Walking at 6 AM”, “PENDING”); Task t2 = new Task(2l, “Breakfast”, “Breakfast 7 AM”, “COMPLETED”); Task t3 = new Task(3l, “Office”, “Office at 9 AM”, “COMPLETED”); Task t4 = new Task(4l, “Lunch”, “Lunch at 1 PM”, “PENDING”); Task t5 = new Task(5l, “Snacks”, “Snacks at 6 PM”, “PENDING”); taskList.add(t1); taskList.add(t2); taskList.add(t3); taskList.add(t4); taskList.add(t5); } @RequestMapping(value = “/tasks”, method = RequestMethod.GET, headers = “Accept=application/json”) public List<Task> getTasks() { return taskList; } @RequestMapping(value = “/addTask”, method = RequestMethod.POST, headers = “Accept=application/json”) public String addTask(@RequestBody Task task) { taskList.add(task); return “Task added Succesfully!!!”; } @RequestMapping(value = “/task/{taskId}”, method = RequestMethod.GET, headers = “Accept=application/json”) public Task getTask(@PathVariable Long taskId) { for (Task task : taskList) { if (task.getId() == taskId) return task; } return null; } @RequestMapping(value = “/deleteTask/{taskId}”, method = RequestMethod.DELETE, headers = “Accept=application/json”) public String deleteTask(@PathVariable Long taskId) { boolean flag = false; Task tempTask = null; for (Task task : taskList) { if (task.getId() == taskId) { tempTask = task; break; } } flag = taskList.remove(tempTask); if (flag) return “Task deleted successfully!!!!!”; else return “Error in deleting Task!!!!!”; } @RequestMapping(value = “/updateTask/{id}/{status}”, method = RequestMethod.PUT, headers = “Accept=application/json”) public String updateTask(@PathVariable Long id, @PathVariable String status) { for (Task task : taskList) { if (task.getId() == id) { task.setStatus(status); } } return “Task updated Succesfully!!!”; } } Below are the annotations used- @RestController – This is a convenience annotation that does nothing more than adding the @Controller and @ResponseBody annotations. (Note – @Controller is used to mark classes as Spring MVC Controller.) @PathVariable – This annotation is used to obtain some placeholder from the URI. Placeholders are generally of primitive datatype. @RequestBody – This annotation is used to obtain some placeholder from the URI. Placeholders are generally of class objects in JSON format. @RequestMapping – This anootation is used map requests from URI to java methods. Spring boot main file Step 6: Create a “SpringBootRestfulApplication.java” file in package com.myjavablog package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringBootRestfulApplication { public static void main(String[] args) { SpringApplication.run(SpringBootRestfulApplication.class, args); } } This is the mail file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work. Let’s understand more about this annotation. @SpringBootApplication is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application context. @EnableAutoConfiguration – It enables Spring boot to add beans presents in classpath setting and various property setting. Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet. @ComponentScan – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers. If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Run the application Step 7: Right Click on Project -> Debug As -> Maven Build Step 8: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 9: Now once the application is up and running, you can access it from POSTMAN tool as below – Get all tasks – Get single task – Add task – Delete task – Update Task – Before After – ... Read more...Spring boot + Angular JS + Hibernate CRUDJune 29, 2018Spring BootGithub Link: Download We are using Spring boot version 1.5.9.RELEASE which has hibernate 5.0 version inside it. We will be creating simple TodoManager application using which we can manage our daily todo tasks. We will be using angular for front end. It will provide user interface from which you can add, update or delete tasks in todo list.We will use controller, services and DAO classes to achieve these functionalities.We will connect to MySQL database using SessionFactory class of hibernate. Tools used for below project – Spring Boot 2.0.2.RELEASE Spring 5.0.6.RELEASE Tomcat Embed 8 Maven 3.3 Java 8 Spring Tool Suite IDE (STS) Hibernate 5 MySql 5.1.21 Step 1: Project Structure Step 2: Create a project named TodoListManager in STS (Refer Create new project in STS) Step 3: Change pom.xml as below – <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.anup.springboot</groupId> <artifactId>TodoListManager</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>TodoListManager Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <!– https://mvnrepository.com/artifact/org.threeten/threetenbp –> <dependency> <groupId>org.threeten</groupId> <artifactId>threetenbp</artifactId> <version>0.7.2</version> </dependency> <!– <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> </dependency> –> <!– H2 Database <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency>–> <!– mySQL DB –> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> <finalName>TodoListManager</finalName> </build> </project> The spring-boot-starter-parent provides you all maven defaults required for any spring project. Since we are developing a web application, we also need to add spring-boot-starter-web dependency. Additionally we need to include spring-boot-starter-data-jpa to run this application with hibernate.You need to also put mysql-connector-java for MySql JDBC driver.If you are using any other database, you need to use different database connector. Let’s do hibernate configuration first. Configure Hibernate – Step 4: Create “HibernateConfiguration.java” file under com.anup.springboot.hibernateconfig package – package com.anup.springboot.hibernateconfig; import java.util.Properties; import javax.sql.DataSource; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.jdbc.datasource.DriverManagerDataSource; import org.springframework.orm.hibernate5.HibernateTransactionManager; import org.springframework.orm.hibernate5.LocalSessionFactoryBean; import org.springframework.transaction.annotation.EnableTransactionManagement; /** * @author anup * */ @Configuration @EnableTransactionManagement public class HibernateConfiguration { @Value(“${db.driver}”) private String DRIVER; @Value(“${db.password}”) private String PASSWORD; @Value(“${db.url}”) private String URL; @Value(“${db.username}”) private String USERNAME; @Value(“${hibernate.dialect}”) private String DIALECT; @Value(“${hibernate.show_sql}”) private String SHOW_SQL; @Value(“${hibernate.hbm2ddl.auto}”) private String HBM2DDL_AUTO; @Value(“${entitymanager.packagesToScan}”) private String PACKAGES_TO_SCAN; @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName(DRIVER); dataSource.setUrl(URL); dataSource.setUsername(USERNAME); dataSource.setPassword(PASSWORD); return dataSource; } @Bean public LocalSessionFactoryBean sessionFactory() { LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean(); sessionFactory.setDataSource(dataSource()); sessionFactory.setPackagesToScan(PACKAGES_TO_SCAN); Properties hibernateProperties = new Properties(); hibernateProperties.put(“hibernate.dialect”, DIALECT); hibernateProperties.put(“hibernate.show_sql”, SHOW_SQL); hibernateProperties.put(“hibernate.hbm2ddl.auto”, HBM2DDL_AUTO); sessionFactory.setHibernateProperties(hibernateProperties); return sessionFactory; } @Bean public HibernateTransactionManager transactionManager() { HibernateTransactionManager transactionManager = new HibernateTransactionManager(); transactionManager.setSessionFactory(sessionFactory().getObject()); return transactionManager; } } This class is annotated with @Configuration and @Bean annotation. These annotations are used to define bean in Spring. @Configuration is analogous to <beans> tag in Spring XML configuration and @Bean is analogous to <bean> tag. @Value annotation is used to inject variables from properties files. In this case, it will read from application.properties which we are going to create in next step. Step 5: Create a “application.properties” file in package /src/main/resources spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8082 logging.level=DEBUG # Database db.driver: com.mysql.jdbc.Driver db.url: jdbc:mysql://localhost:3306/todomanager db.username: root db.password: # Hibernate hibernate.dialect: org.hibernate.dialect.MySQL5Dialect hibernate.show_sql: true hibernate.hbm2ddl.auto: update entitymanager.packagesToScan: com spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true Step 7: Create a “Todo.java” model class in com.anup.springboot.pojo package package com.anup.springboot.pojo; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; /** * @author anup * */ @Entity @Table(name = “TODO”) public class Todo implements Serializable { public Todo() { super(); } public Todo(Long id, String taskName, String taskDesc, String status) { super(); this.id = id; this.taskName = taskName; this.taskDesc = taskDesc; this.status = status; } @Id @Column(name = “ID”) @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = “TASK_NAME”) private String taskName; @Column(name = “TASK_DESC”) private String taskDesc; @Column(name = “STATUS”) private String status; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getTaskName() { return taskName; } public void setTaskName(String taskName) { this.taskName = taskName; } public String getTaskDesc() { return taskDesc; } public void setTaskDesc(String taskDesc) { this.taskDesc = taskDesc; } public String getStatus() { return status; } public void setStatus(String status) { this.status = status; } } @Entity – This marks class as Entity @Table – This maps class to database table @Id – Marks the class variable as primary key column in table @Column – Marks it as a column in table , we can also configure name attribute defining its name in database table @GeneratedValue – Marking a field with the @GeneratedValue annotation specifies that a value will be automatically generated for that field. This is primarily intended for primary key fields .There are below types of strategies – GenerationType.AUTO – It is the default generation type and lets the persistence provider choose the generation strategy. @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.IDENTITY – The GenerationType.IDENTITY is the easiest to use but not the best one from a performance point of view. It relies on an auto-incremented database column and lets the database generate a new value with each insert operation. From a database point of view, this is very efficient because the auto-increment columns are highly optimized, and it doesn’t require any additional statements. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.SEQUENCE – The GenerationType.SEQUENCE is my preferred way to generate primary key values and uses a database sequence to generate unique values. If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) @Column(name = “id”, updatable = false, nullable = false) private Long id; You can change that by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation. The @SequenceGenerator annotation lets you define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence. @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = “book_generator”) @SequenceGenerator(name=”book_generator”, sequenceName = “book_seq”, allocationSize=50) @Column(name = “id”, updatable = false, nullable = false) private Long id; GenerationType.TABLE – The GenerationType.TABLE gets only rarely used nowadays. It simulates a sequence by storing and updating its current value in a database table which requires the use of pessimistic locks which put all transactions into a sequential order. This slows down your application, and you should, therefore, prefer the GenerationType.SEQUENCE, if your database supports sequences, which most popular databases do If you don’t provide sequence name hibernate will provide its default sequence @Id @GeneratedValue(strategy = GenerationType.TABLE) @Column(name = “id”, updatable = false, nullable = false) private Long id; Summary: AUTO: Hibernate selects the generation strategy based on the used dialect, IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key, SEQUENCE: Hibernate requests the primary key value from a database sequence, TABLE: Hibernate uses a database table to simulate a sequence. Step 6: Create database tables create table TODO (id bigint NOT NULL AUTO_INCREMENT, TASK_NAME varchar(255), TASK_DESC varchar(255), STATUS varchar(255) , primary key (id)); INSERT INTO TODO VALUES(1, ‘Bath’, ‘Have a bath’ , ‘PENDING’ ); INSERT INTO TODO VALUES(2, ‘Snacks’, ‘Have snacks’ , ‘PENDING’ ); Controller class Step 7: Create class “TodoController.java” in package com.anup.springboot.controller package com.anup.springboot.controller; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import com.anup.springboot.pojo.Todo; import com.anup.springboot.service.TodoService; /** * @author anup * */ @RestController public class TodoController { @Autowired TodoService service; @RequestMapping(value = “/”, method = RequestMethod.GET) public String getHomePage() { return “index”; } @RequestMapping(value = “/todos/addTodo”, method = RequestMethod.POST, headers = “Accept=application/json”) public Todo addTodo(@RequestBody Todo t) { Todo todo = service.addTodo(t); return todo; } @RequestMapping(value = “/todos/updateTodo”, method = RequestMethod.PUT, headers = “Accept=application/json”) public Todo updateTodo(@RequestBody Todo t) { service.updateTodo(t); return t; } @RequestMapping(value = “/todos/getAllTodos”, method = RequestMethod.GET, headers = “Accept=application/json”) public List<Todo> getAllTodos() { List<Todo> todoList = service.getAllTodos(); return todoList; } @RequestMapping(value = “/todos/deleteTodo/{id}”, method = RequestMethod.DELETE, headers = “Accept=application/json”) public void deleteCust(@PathVariable long id) { service.deleteTodo(id); } } Service Layer Step 8: Create interface named “TodoService.java” in package com.anup.springboot.service package com.anup.springboot.service; import java.util.List; import com.anup.springboot.pojo.Todo; /** * @author anup * */ public interface TodoService { public List<Todo> getAllTodos(); public Todo getTodo(Long id); public Todo addTodo(Todo t); public Todo updateTodo(Todo t); public void deleteTodo(Long id); } Step 9: Create class named “TodoServiceImpl.java” in package com.anup.springboot.service package com.anup.springboot.service; import java.util.ArrayList; import java.util.List; import javax.transaction.Transactional; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.anup.springboot.dao.TodoRepository; import com.anup.springboot.pojo.Todo; /** * @author anup * */ @Service(“todoService”) public class TodoServiceImpl implements TodoService { @Autowired TodoRepository dao; @Override @Transactional public List<Todo> getAllTodos() { List<Todo> todoList = new ArrayList<>(); dao.findAll().forEach(e -> todoList.add(e)); return todoList; } @Override @Transactional public Todo getTodo(Long id) { Todo todo = dao.findOne(id); return todo; } @Override @Transactional public synchronized Todo addTodo(Todo t) { dao.save(t); return t; } @Override @Transactional public Todo updateTodo(Todo t) { dao.save(t); return t; } @Override @Transactional public void deleteTodo(Long id) { dao.delete(id); } } DAO Layer Step 10: Create interface “TodoDao.java” in package com.anup.springboot.dao package com.anup.springboot.dao; import java.util.List; import com.anup.springboot.pojo.Todo; /** * @author anup * */ public interface TodoDao { public void addTodo(Todo c); public List<Todo> getTodos(); public void deleteTodo(int id); public void updateTodo(Todo c); public Todo getTodo(int id); } Step 11: Create class “TodoDaoImpl.java” in package com.anup.springboot.dao package com.anup.springboot.dao; import java.util.List; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import com.anup.springboot.pojo.Todo; /** * @author anup * */ @Repository(“todoDao”) public class TodoDaoImpl implements TodoDao { @Autowired private SessionFactory sessionFactory; public void setSessionFactory(SessionFactory sessionFactory) { this.sessionFactory = sessionFactory; } @Override public void addTodo(Todo c) { Session session = sessionFactory.getCurrentSession(); session.save(c); } @Override public List<Todo> getTodos() { Session session = sessionFactory.getCurrentSession(); List<Todo> list = session.createQuery(“from Todo”).list(); return list; } @Override public void deleteTodo(int id) { Session session = sessionFactory.getCurrentSession(); Todo c = session.load(Todo.class, new Integer(id)); if (c != null) session.delete(c); } @Override public void updateTodo(Todo c) { Session session = sessionFactory.getCurrentSession(); session.update(c); } @Override public Todo getTodo(int id) { Session session = sessionFactory.getCurrentSession(); Todo c = (Todo) session.get(Todo.class, id); return c; } } AngularJS UI Layer Step 12: Create “index.jsp” under \src\main\webapp\WEB-INF\views\ <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″ pageEncoding=”ISO-8859-1″%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <%@ taglib uri=”http://java.sun.com/jsp/jstl/core” prefix=”c”%> <%@ taglib uri=”http://www.springframework.org/tags” prefix=”spring”%> <%@ taglib uri=”http://www.springframework.org/tags/form” prefix=”form”%> <html> <head> <link href=”/css/app.css” rel=”stylesheet”/> <script src=”https://ajax.googleapis.com/ajax/libs/angularjs/1.4.4/angular.js”></script> <script type=”text/javascript” src=”/js/app.js”></script> <meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″> <title>Todo Manager</title> </head> <body ng-app=”todoManager” ng-controller=”todoController”> </br> <h4 class=”todo”>Todo Manager</h4> <form ng-submit=”submitTodo()”> <table> <tr> <th colspan=”2″>Add/Edit todo</th> </tr> <tr> <td>Task Name</td> <td><input type=”text” ng-model=”todoForm.taskName” /></td> </tr> <tr> <td>Task Desc</td> <td><input type=”text” ng-model=”todoForm.taskDesc” /></td> </tr> <tr> <td>Status</td> <td><select id=”status” ng-model=”todoForm.status” ng-options=”x for x in status” /></select></td> </tr> <tr> <td colspan=”2″><input type=”submit” value=”Submit” class=”blue-button” /></td> </tr> </table> </form> <table> <tr> <th width=”120″>Task Name</th> <th width=”120″>Task Desc</th> <th width=”60″>Status</th> <th width=”60″>Operations</th> </tr> <tr ng-repeat=”todo in todos” ng-init=”statusCls=getClass(todo)”> <td>{{ todo.taskName }}</td> <td>{{ todo.taskDesc }}</td> <td class=”statusCls”> {{ todo.status }} </td> <td><a ng-click=”editTodo(todo)” class=”blue-button”>Edit</a> | <a ng-click=”deleteTodo(todo)” class=”red-button”>Delete</a></td> </tr> </table> </body> </html> Step 13: Create javascript file “app.js” under \src\main\resources\static\js\ var app = angular.module(“todoManager” , []); app.controller(“todoController” , function($scope, $http){ $scope.todos = []; $scope.status = ; $scope.todoForm = { id : -1, taskName : “”, taskDesc : “” }; $scope.getClass = function(todo){ if(todo.status == ‘PENDING’) return ‘red’; else if(todo.status == ‘COMPLETED’){ return ‘green’; } } _refreshTodoData(); function _refreshTodoData(){ $http({ method : ‘GET’, url : ‘http://localhost:8082/todos/getAllTodos’ }).then(function successCallback(response) { $scope.todos = response.data; //alert($scope.todos); }, function errorCallback(response) { console.log(response.statusText); }); } $scope.submitTodo = function() { var method = “”; var url = “”; if ($scope.todoForm.id == -1) { //Id is absent in form data, it is create new todo operation method = “POST”; url = ‘/todos/addTodo’; } else { //Id is present in form data, it is edit todo operation method = “PUT”; url = ‘/todos/updateTodo’; } $http({ method : method, url : url, data : angular.toJson($scope.todoForm), headers : { ‘Content-Type’ : ‘application/json’ } }).then( _success, _error ); }; $scope.deleteTodo = function(todo) { $http({ method : ‘DELETE’, url : ‘/todos/deleteTodo/’ + todo.id }).then(_success, _error); }; $scope.editTodo = function(todo) { $scope.todoForm.taskName = todo.taskName; $scope.todoForm.taskDesc = todo.taskDesc; $scope.todoForm.status = todo.status; $scope.todoForm.id = todo.id; }; function _success(response) { //alert(“success”); _refreshTodoData(); _clearFormData(); } function _error(response) { //alert(“error”); console.log(response.statusText); } //Clear the form function _clearFormData() { $scope.todoForm.id = -1; $scope.todoForm.taskName = “”; $scope.todoForm.taskDesc = “”; $scope.todoForm.status = “”; }; }); Step 14: Create CSS file “app.css” under \src\main\resources\static\css\ for adding style .blue-button { background: #25A6E1; filter: progid: DXImageTransform.Microsoft.gradient( startColorstr=’#25A6E1′, endColorstr=’#188BC0′, GradientType=0); padding: 3px 5px; color: #fff; font-family: ‘Helvetica Neue’, sans-serif; font-size: 12px; border-radius: 2px; -moz-border-radius: 2px; -webkit-border-radius: 4px; border: 1px solid #1A87B9; cursor: pointer; } .red-button { background: #CD5C5C; padding: 3px 5px; color: #fff; font-family: ‘Helvetica Neue’, sans-serif; font-size: 12px; border-radius: 2px; -moz-border-radius: 2px; -webkit-border-radius: 4px; border: 1px solid #CD5C5C; cursor: pointer; } table { font-family: “Helvetica Neue”, Helvetica, sans-serif; width: 50%; } caption { text-align: left; color: silver; font-weight: bold; text-transform: uppercase; padding: 5px; } th { background: SteelBlue; color: white; } tbody tr:nth-child(even) { background: WhiteSmoke; } tbody tr td:nth-child(2) { text-align: center; } tbody tr td:nth-child(3), tbody tr td:nth-child(4) { text-align: center; font-family: monospace; } tfoot { background: SeaGreen; color: white; text-align: right; } tfoot tr th:last-child { font-family: monospace; } td, th { border: 1px solid gray; width: 25%; text-align: left; padding: 5px 10px; } #status{ width: 53%; padding: 1px 0; } .todo { font-size: 24px; color: #CD5C5C; text-transform: uppercase; font-family: arial; width: 50%; background: #ccc; text-align: center; border-radius: 4px; margin: 2% 0%; padding: 3px 0; box-shadow: 0px 1px 7px 1px grey; } .pending{ color: red; } .completed{ color: green; } $http – It’s used to make AJAX calls to server in order to submitTodo(), deleteTodo() , editTodo() task. When you click on submit button on form, it actually calls POST or PUT depending on operation. If you click on edit and submit data then it will be PUT operation as it will update existing resource. If you directly submit data, then it will be POST operation to create new resource. Every time you submit data, it calls _refreshTodoData() to refresh Todo table below. When you call $http, you need to pass method type and URL, it will call it according, You can either put absolute URL or relative URL with respect to context root of web application. Spring boot main file Step 15: Create “TodoManagerApplication.java” a main spring file under com.anup.springboot package com.anup.springboot; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class TodoManagerApplication { public static void main(String[] args) { SpringApplication.run(TodoManagerApplication.class, args); } } This is the mail file which bootstraps spring application. We have just added @SpringBootApplication and it does all the work. Let’s understand more about this annotation. @SpringBootApplication is an annotation that adds all of the following: @Configuration – It makes the class as a source of bean definitions for the application context. @EnableAutoConfiguration – It enables Spring boot to add beans presents in classpath setting and various property setting. Normally you would add @EnableWebMvc for a Spring MVC application, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet. @ComponentScan – It tells Spring to look for other components, configurations, and services in the default package, allowing it to find the controllers. If specific packages are not defined, scanning will occur from the package of the class that declares this annotation. Run the application Step 16: Right Click on Project -> Debug As -> Maven Build Step 17: Provide goals as below – mvn clean install spring-boot:run (Cmd prompt) Or Step 18: Now once the application is up and running, you can access it from below link – Adding new task – Editing the task – Deleting the task – ... Read more...Spring boot Hello worldJune 29, 2018Spring BootSpring Tool Suite(STS) makes it easy to develop spring boot applications.We will create a simple HelloWorld application using spring boot. Tools used to create below project – Spring Boot 2.0.2.RELEASE Spring 5.0.6.RELEASE Tomcat Embed 8 Maven 3.3 Java 8 Spring Tool Suite IDE (STS) Github Link : Download Step 1: Go to File -> New -> Spring Starter Project . Then you need to configure project name, group, artifact and package as shown below – Step 2: Configure maven dependencies You just need to select dependencies and STS will automatically pull these dependencies for you . Please refer below screenshot – For this project we just need web dependency. Below pom.xml generated after clicking on finish. Additionally add tomcat-embed-jasper and JSTL dependencies to it. <?xml version=”1.0″ encoding=”UTF-8″?> <project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”> <modelVersion>4.0.0</modelVersion> <groupId>com.myjavablog</groupId> <artifactId>SpringBootHelloWorld</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>SpringBootHelloWorld</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.2.RELEASE</version> <relativePath/> <!– lookup parent from repository –> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!– JSTL for JSP –> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <!– For JSP compilation –> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> Below project structure will be created for you by STS. SpringBootHelloWorldApplication.java package com.myjavablog; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringBootHelloWorldApplication { public static void main(String[] args) { SpringApplication.run(SpringBootHelloWorldApplication.class, args); } } This is the main file which bootstraps the spring application. This is generated by STS for us. Step 4: Create a controller class HelloWorldController.java package com.myjavablog.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @Controller public class HelloWorldController { @RequestMapping(value=”/”, method=RequestMethod.GET) public String getHomePage() { return “index”; } } Step 5: Create index.jsp index.jsp <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″ pageEncoding=”ISO-8859-1″%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”> <%@ taglib uri=”http://java.sun.com/jsp/jstl/core” prefix=”c”%> <%@ taglib uri=”http://www.springframework.org/tags” prefix=”spring”%> <%@ taglib uri=”http://www.springframework.org/tags/form” prefix=”form”%> <html> <head> <meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″> <title>Hello World</title> </head> <body > </br> <h4>Hello World!!!</h4> </body> </html> Step 6: Clean and install project Now run the maven clean install phase as below – Command: mvn clean install OR Right click on project -> Debug As -> Maven build . Below popup will come up – Enter clean install and click on debug. After successful build, it will create below artifacts in target folder – Step 7: Run the spring application Command: mvn spring-boot:run OR Right click on project -> Debug As -> Spring boot App Now spring boot will internally host the application on embeded tomcat server . You can access your application through below url – http://localhost:8080/ Note: You can configure details like port number, view files location , database properties in file present inside /src/main/resources/application.properties file. Ex. – application.properties spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp server.port=8082... Read more...Spring boot introductionJune 29, 2018Spring BootWhat’s spring boot? You can easily develop web applications using spring boot . It provides default configuration and thus reducing lot of boilerplate code. Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run” as packaged jar file. Ex. java -jar SampleApp.jar Why spring boot? Suppose you are using spring MVC to develop web application. You need to do lot of configurations for it such as datasource, transaction management, security, EntityManager etc. You have to define all dependencies required for the application. But with the spring boot , you don’t need to worry about the configuration part. Also spring boot comes with all the dependencies package com.myjavablog.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; @Controller public class HelloWorldController { @GetMapping(“/”) public String getHomePage() { return “index”; } } Advantages It provides a radically faster and widely accessible ‘getting started’ experience for all Spring development Its opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults It provides a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration)... Read more...
