@Component -- when used above the class , it will create bean of that class which will be injected when the class called with @Autowired annotation.
It can be used in any class or interface.@Component
public class ProductService {
...
}
@Service -- same as @Component annotation but can be used only on service layer class (ie. where your business logic goes).
@Service
public class ProductService {
...
}
@Repository --same as @Component annotation but can be used only on persistence layer (ie. storage , retrieval of data).
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
.....
}
Here "ProductRepository" extends JpaRepository , so it can have all JPA methods like findAll , findById etc . If you want to know more about JpaMethods click here.
"Product" is the entity or table and Long is the auto generated id for entity "Product".
@Controller --same as @Component annotation but can be used only on presentation layer (ie. where your define your api).
@Controller
@Path("product")
public class ProductResource {
...
}
@Path is used to specify the api path.
@RequestMapping -- used in classes on presentation layer for rest API's (GET,POST,PUT and DELETE methods).
@Controller
@Path("product")
public class ProductResource {
Autowired
ProductService productService;
@RequestMapping(value = "/id", method = RequestMethod.GET, produces = {
"application/JSON"
})
@ResponseBody
List<Vendor> getProductDetail() {
return productService.getProductDetail();
}
}
RequestMapping(value = "/id", method = RequestMethod.GET, produces = {"application/JSON"}) -Here the request method is GET and return value is of type JSON.
Example for service , controller with repository
ProductService.java
@Componentpublic class ProductService {
Autowired
ProductRepository productRepository;
public List<Product> getProductData() throws IOException {
List<Product> productDataList = articleRepository.getProductData();
return productDataList;
}
}
ProductRepository.java
@Repositorypublic interface ProductRepository extends JpaRepository<Product, Long> {
@Query("select p from Product p")
List<Product> getProductData();
}
ProductResource.java
@Controller@Path("product")
public class ProductResource {
Autowired
ProductService productService;
@RequestMapping(value = "/prod", method = RequestMethod.GET, produces = {
"application/JSON"
})
@ResponseBody
List<Product> getProductData() {
return productService.getProductData();
}
}
@Autowired -- used to inject the created bean of a class into a reference object.
@Component
public class SampleService {
Autowired
SampleRepository sampleRepository;
....
}
Here sampleRepository is used to access all the methods with in the SampleRepository.
@Async -- used to define a process as seperate thread which is independent of current thread output.The method which uses @Async annotation will run parallely to the method which called it.You can return async method with FUTURE datatype return value or it can be a void method.
@Async
public void loadProductDescription() {
productRepository.productLoadDescriptionEvict();
}
loadProductDescription -- this method should be called from another class for Async to properly work.Create another class and call this method ,
so it can run parallel corresponding to the method called it.
@Transactional -- when you put this annotation above any method it will take care of database management.That is it takes care of open a transaction and commit a transaction , if any error occur it will roll down the transaction and if succeeded , it wil close the transaction.
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveOrUpdateArticleInfoVendorList(Long vendor) throws IOException, JAXBException {
List<Product> ProductListForVendorId = productRepository
.findByVendor(vendor);
if (ProductListForVendorId != null) {
for (int j = 0; j < ProductListForVendorId.size(); j++) {
updatProductInfoForEachProduct(ProductListForVendorId.get(j).getProductId());
}
}
}
@Transactional -- this method will be executed as seperate transaction.
@Scheduled -- used for executing time based jobs. If you want a method to execute at particular time , you should annotate the method with @Scheduled annotation.
@Scheduled(cron = "0 5 * * * ?")
public void productUpdateJob() {
productRepository.updateProdcutDescriptionFromSource();
}
Here the prodcut description will be updated from given source for 05:00 in the morning.
@Value -- used to retrieve value stored in application.properties file
@Value("${token.secret.key}")
private String secretKeyForToken;
Here token.secret.key - is the key present in application.properties.
secretKeyForToken - hold the value for the key specified.
In application.properties file,
token.secret.key = sddfe34343dsdweed@#%
@SpringBootApplication -- this annotation enables the project as spring boot application.
@EnableCaching -- to enable cache in your spring boot application
@EnableAsync -- to enable async in your sping boot application
@EnableRetry -- to enable retry logic in your sping boot application
@EntityScan -- the classes within the specified packages only be scanned for bean creation.
@EnableJpaRepositories -- to enable JPA repository in your sping boot application
@SpringBootApplication
@EnableCaching
@EnableAsync
@EnableRetry
@EntityScan(basePackages = { "com.learnsoftware.productmanagement" })
@EnableJpaRepositories(basePackages = { "com.learnsoftware.productmanagement" })
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Here the classes within "com.learnsoftware.productmanagement" package only scanned and nly enable for JpaRepository .
@Cacheable -- used to catch the data with the specified cache name.
@CacheEvict -- used to clear the data with the specified cache name.
@Cacheable("ProductCodeAndDescription")
public List<ProductCodeAndDescription> getAllProductCodeAndDescription() {
String qry = "select p.product_id,p.product_description from product p";
Query query = entityManager.createNativeQuery(qry);
List<Object[]> productList = query.getResultList();
ProductCodeAndDescription productCodeAndDescription = null;
List<ProductCodeAndDescription> productCodeAndDescriptionList = new ArrayList<>();
for (Object[] row : productList) {
productCodeAndDescription = new ProductCodeAndDescription();
productCodeAndDescription.setProductId(Long.parseLong(row[0].toString()));
productCodeAndDescription.setProductDescription(row[1].toString());
productCodeAndDescriptionList.add(productCodeAndDescription);
}
return productCodeAndDescriptionList;
}
@CacheEvict(value = "ProductCodeAndDescription", allEntries = true)
public void evictProdcutDetails() {
}
Here "ProductCodeAndDescription" - is the name of the cache.
@retryable -- used to retry the method if fails (due to network issues) for the specified the count.
@Recover -- if the method fails even after retry attempts , then the annotated with @Recover will be called.
Note: the method should throw the secified exception(SQLException) in order to come to recovery method.@Retryable(value = { SQLException.class }, maxAttempts = 3, backoff = @Backoff(delay = 1000))
public String getProductResponse(){
...
}
There will be up to 3 retries with a delay of 1000 milliseconds.
@Recover
void recoverMethod(SQLException e, String sql){
...
}
@Scope -- to specify the scope of the bean . By default scope will be singleton. If you want more information about scope click here.
@Component@Scope("prototype")
public class ProductService {
...
}
JpaRepository annotations
@Repository --same as @Component annotation but can be used only on persistence layer (ie. storage , retrieval of data).
@Modifying -- should use when a query tries to modify your table .
@Query -- query which does transaction goes with this annotation.
@Param -- used to specify the parameters which will be used within the query.
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
@Modifying
@Transactional
@Query(value = "UPDATE product SET status=:status WHERE product_id=:productId", nativeQuery = true)
void updateProductStatus(@Param("productId") Long productId, @Param("status") Integer status);
}
Here "productId" and "status" are two parameters which should be specified with colon(:).
nativeQuery = true -- to specify it as native query.
@Transactional -- to specify it as a seperate transaction.
Jersy Rest Api Annotations
@GET --- should use for retrieving the data.
@Path -- used to specify the path for the api.
@Produces -- used to specify the return type of the method.
@Consumes -- used to specify the input type of the method
@PUT -- should use for updating the data.
@POST -- should use for inserting or updating the data.
@Delete -- should use for deleting the data.
@PathParam -- used to specify the path related params
@FormDataParam -- used to specify the file input
@QueryParam -- used for string or integer input
