Merge pull request #2 from sujitmajumdar42/master

CodeStuff-Repo · web-flow · commit 98e2e8ad0306 · 2018-07-15T22:15:25.000+05:30
Merging Initial Commit
diff --git a/README.md b/README.md
@@ -0,0 +1,71 @@
+# Memcached with Spring Boot [![MIT license](https://img.shields.io/badge/license-GPL_3.0-yellow.svg)](https://raw.githubusercontent.com/CodeStuff-Repo/Spring_Memcached/master/LICENSE)
+## Why Memcached ?
+##### *Are you interacting with Database for each transaction?*
+Then you must apply a cache mechanism to avoid multiple database calls and faster response.
+## [Memcached](https://memcached.org/)
+A free, opensource, in-memory caching system to speedup application by reducing database load.
+## Memcached with Spring
+In this project you will find basic usage of memcached in spring **REST** application.
+## How to use?
+### Add dependency
+// For Gradle project add following dependency.
+
+```groovy
+compile("net.spy:spymemcached:2.12.3")
+```
+### Setup Memcached
+Add ***MemcachedClient*** bean in your springboot config file.
+
+```java
+// Connecting to memcached
+// [host = localhost ,PORT = 11211]
+// Initializing MemcachedClient.
+@Bean
+	public MemcachedClient cacheClient() {
+		InetSocketAddress ia = new InetSocketAddress("localhost", 11211);
+		MemcachedClient cacheClient = null;
+		try {
+		 cacheClient = new MemcachedClient(ia);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		LOGGER.info("Cache setup done.");
+		return cacheClient;
+	}
+```
+#### Done !!!!
+Now you are ready to use memcache hosted on your local machine.  
+Its simple, right?
+
+### Add something to cache
+```java
+@Autowired
+private MemcachedClient memcachedClient;
+
+memcachedClient.add(key, 0, value);
+```
+### Fetch from cache
+```java
+String value = (String) memcachedClient.get(key);
+```
+
+### Delete from cache
+```java
+memcachedClient.delete(key);
+```
+
+### Flush everything
+```java
+memcachedClient.flush();
+```
+## Want more?
+Memcached provides lot more features for caching.  
+Still confused ? then,
+### Fork it and explore !!!!
+
+## Technology Stacks
+| Stack | Detail |
+| ------ | ------ |
+| Java | [Java 8](https://www.oracle.com/technetwork/java/javase/overview/java8-2100321.html) |
+|Spring boot| [2.0.3.RELEASE](https://github.com/spring-projects/spring-boot) |
+|Database|MySql|
diff --git a/build.gradle b/build.gradle
@@ -0,0 +1,32 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.3.RELEASE")
+    }
+}
+
+apply plugin: 'java'
+apply plugin: 'eclipse'
+apply plugin: 'org.springframework.boot'
+apply plugin: 'io.spring.dependency-management'
+
+bootJar {
+    baseName = 'gs-spring-boot'
+    version =  '0.1.0'
+}
+
+repositories {
+	mavenCentral()
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+dependencies {
+    compile("org.springframework.boot:spring-boot-starter-web")
+    compile("org.springframework.boot:spring-boot-starter-jdbc")
+    compile("mysql:mysql-connector-java")
+    compile("net.spy:spymemcached:2.12.3")
+ }
diff --git a/src/main/java/com/codestuff/springcache/config/Application.java b/src/main/java/com/codestuff/springcache/config/Application.java
@@ -0,0 +1,38 @@
+package com.codestuff.springcache.config;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+
+import net.spy.memcached.MemcachedClient;
+
+@SpringBootApplication
+@ComponentScan(basePackages = { "com.codestuff.springcache.*" })
+public class Application {
+	
+	private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
+	
+	public static void main(String[] args) {
+		SpringApplication.run(Application.class, args);
+		LOGGER.info("Application is ready.");
+	}
+
+	@Bean
+	public MemcachedClient cacheClient() {
+		InetSocketAddress ia = new InetSocketAddress("localhost", 11211);
+		MemcachedClient cacheClient = null;
+		try {
+		 cacheClient = new MemcachedClient(ia);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		LOGGER.info("Cache setup done.");
+		return cacheClient;
+	}
+}
diff --git a/src/main/java/com/codestuff/springcache/controller/EmployeeController.java b/src/main/java/com/codestuff/springcache/controller/EmployeeController.java
@@ -0,0 +1,70 @@
+package com.codestuff.springcache.controller;
+
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.codestuff.springcache.dao.EmployeeDAO;
+import com.codestuff.springcache.pojo.Employee;
+import com.codestuff.springcache.service.EmployeeService;
+
+
+@RestController
+public class EmployeeController {
+	
+	private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeController.class);
+	
+	@Autowired
+	private EmployeeDAO employeeDAO;
+	
+	@Autowired
+	private EmployeeService service;
+	
+	@RequestMapping("/")
+    public String index() {
+        return "OK";
+    }
+	
+	@RequestMapping(path="/insert")
+	public void insert(@RequestParam String name, @RequestParam String place) {
+		Employee emp = new Employee();
+			emp.setEmpId(""+System.currentTimeMillis());
+			emp.setName(name);
+			emp.setPlace(place);
+		employeeDAO.insert(emp);
+		LOGGER.info("Employee has been created. "+emp);
+	}
+	
+	@RequestMapping(path="/update")
+	public void update(@RequestParam String empid, @RequestParam String name, @RequestParam String place) {
+		Employee emp = new Employee();
+			emp.setEmpId(empid);
+			emp.setName(name);
+			emp.setPlace(place);
+		service.update(emp);
+		LOGGER.info("Employee updated. "+emp);
+	}
+	
+	@RequestMapping(path="/fetchName")
+	public String get(String empID) {
+		return empID+" : "+service.getName(empID);
+	}
+	
+	@RequestMapping(path="/fetchAll",produces=MediaType.APPLICATION_JSON_VALUE)
+	public List<Employee> getAll() {
+		LOGGER.info("Fetching all employees.");
+		return service.getAll();
+	}
+	
+	@RequestMapping(path="/flush")
+	public void flushCache() {
+		service.flushCache();
+		LOGGER.info("All cache has been flushed.");
+	}
+}
diff --git a/src/main/java/com/codestuff/springcache/dao/EmployeeDAO.java b/src/main/java/com/codestuff/springcache/dao/EmployeeDAO.java
@@ -0,0 +1,43 @@
+package com.codestuff.springcache.dao;
+
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+import com.codestuff.springcache.pojo.Employee;
+
+@Component
+public class EmployeeDAO implements IEmployeeDAO {
+	
+	private static final String INSERT = "INSERT INTO EMPLOYEE(EMP_ID,NAME,PLACE) VALUES(?,?,?)";
+	private static final String FETCH  = "SELECT * FROM EMPLOYEE WHERE EMP_ID=?";
+	private static final String FETCH_ALL  = "SELECT * FROM EMPLOYEE";
+	private static final String UPDATE = "UPDATE EMPLOYEE SET NAME=?, PLACE=? WHERE EMP_ID=?"; 
+	
+	@Autowired
+	private JdbcTemplate jdbcTemplate;
+	
+	@Override
+	public void insert(Employee employee) {
+		jdbcTemplate.update(INSERT,employee.getEmpId(),employee.getName(),employee.getPlace());
+
+	}
+	
+	@Override
+	public Employee get(String empID) {
+		return jdbcTemplate.queryForObject(FETCH, new EmployeeMapper(),empID);
+	}
+	
+	@Override
+	public List<Employee> getAll() {
+		return jdbcTemplate.query(FETCH_ALL, new EmployeeMapper());
+	}
+
+	@Override
+	public void update(Employee employee) {
+		jdbcTemplate.update(UPDATE,employee.getName(),employee.getPlace(),employee.getEmpId());
+	}
+
+}
diff --git a/src/main/java/com/codestuff/springcache/dao/EmployeeMapper.java b/src/main/java/com/codestuff/springcache/dao/EmployeeMapper.java
@@ -0,0 +1,21 @@
+package com.codestuff.springcache.dao;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.springframework.jdbc.core.RowMapper;
+
+import com.codestuff.springcache.pojo.Employee;
+
+public class EmployeeMapper implements RowMapper<Employee> {
+
+	@Override
+	public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
+		Employee employee = new Employee();
+			employee.setEmpId(rs.getString("EMP_ID"));
+			employee.setName(rs.getString("NAME"));
+			employee.setPlace(rs.getString("PLACE"));
+		return employee;
+	}
+
+}
diff --git a/src/main/java/com/codestuff/springcache/dao/IEmployeeDAO.java b/src/main/java/com/codestuff/springcache/dao/IEmployeeDAO.java
@@ -0,0 +1,16 @@
+package com.codestuff.springcache.dao;
+
+import java.util.List;
+
+import org.springframework.stereotype.Repository;
+
+import com.codestuff.springcache.pojo.Employee;
+
+@Repository
+public interface IEmployeeDAO {
+	
+	public void insert(Employee employee);
+	public Employee get(String empID);
+	public List<Employee> getAll();
+	public void update(Employee employee);
+}
diff --git a/src/main/java/com/codestuff/springcache/pojo/Employee.java b/src/main/java/com/codestuff/springcache/pojo/Employee.java
@@ -0,0 +1,36 @@
+package com.codestuff.springcache.pojo;
+
+public class Employee {
+	
+	private String empId;
+	private String name;
+	private String place;
+	
+	public String getEmpId() {
+		return empId;
+	}
+	public void setEmpId(String empId) {
+		this.empId = empId;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getPlace() {
+		return place;
+	}
+	public void setPlace(String place) {
+		this.place = place;
+	}
+	
+	public String toString() {
+		StringBuffer emp = new StringBuffer("EMPID=").append(this.empId).append(" ")
+									.append("NAME=").append(this.name).append(" ")
+									.append("PLACE=").append(this.place);
+		
+		return emp.toString();
+	}
+	
+}
diff --git a/src/main/java/com/codestuff/springcache/service/EmployeeService.java b/src/main/java/com/codestuff/springcache/service/EmployeeService.java
@@ -0,0 +1,52 @@
+package com.codestuff.springcache.service;
+
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.codestuff.springcache.dao.EmployeeDAO;
+import com.codestuff.springcache.pojo.Employee;
+
+import net.spy.memcached.MemcachedClient;
+
+@Service
+public class EmployeeService {
+	
+	private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeService.class);
+	
+	@Autowired
+	private EmployeeDAO employeeDAO;
+	
+	@Autowired
+	private MemcachedClient cacheClient;
+	
+	public String getName(String empID) {
+		String name = null;
+		if(cacheClient.get(empID)==null) {
+			LOGGER.info("Couldn't find EMPID in cache. Fetching from DB.");
+			name = employeeDAO.get(empID).getName();
+			cacheClient.add(empID, 0, name);
+		} else {
+			LOGGER.info("You are lucky, EMPID detected in cache.");
+			name = (String) cacheClient.get(empID);
+		}
+		return name;
+	}
+	
+	public List<Employee> getAll() {
+		return employeeDAO.getAll();
+	}
+	
+	public void update(Employee employee) {
+		cacheClient.delete(employee.getEmpId());
+		LOGGER.info("Cache deleted for "+employee.getEmpId());
+		employeeDAO.update(employee);
+	}
+	
+	public void flushCache() {
+		cacheClient.flush();
+	}
+}
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
@@ -0,0 +1,5 @@
+server.contextPath=/springbootds
+spring.datasource.url=jdbc:mysql://localhost:3306/TEST?autoReconnect=true&useSSL=false
+spring.datasource.username=root
+spring.datasource.password=admin123
+spring.datasource.driver-class-name=com.mysql.jdbc.Driver
diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml
