Enable JPA Tools in Eclispe

Hello Guys..

Sometime we need to generate entities from the database table or vice versa. Off course we can do it manually, but that is huge time consuming process.

In those situations, JPA Tools comes into action and plays a handy role creating the entities from already existing the database. How can we do that in our project.

  1. Convert the project into JPA Project. (Right click on project -> configurations -> convert to JPA Project)
  2. Once converted, again right click on the same project and you will see a “JPA TOOLS” in the context menu options.
  3. There you will see “Generate tables from entities” and few more options.

Now if you are using STS, you will wonder why you can not convert the given project to JPA project. In fact the option in configuration is missing itself. Then how can we convert the project??

Continue reading

Advertisements

Java Eclipse/STS Tips | Disable formatting for specific section

Sometimes which is a necessary and we get habituated off using that more often then not may cause an undesirable effect. Confused?

Let me give you an example of how a frequently used practise possess issues.
Consider “formatting” (CTRL + SHIFT + F), this has been one of the favourite combination for all eclipse users .

If you are a java or spring developer, then you might have figured it out… right ?

No? No issues .. In Java when we use streams and we intentionally break steps  of the chain logically. But if we intended Eclipse to format all the codes in that .java file, it do not understands our logical breaking and brings everything to one line. Also Spring developers might have faced it during Security Configurations with HTTP chaining.

Before formatting

List persons = new ArrayList();
String name = persons.stream()
		.filter(x -> "sovan".equals(x.toString()))
		.map(String::toLowerCase)						
		.findAny()
		.orElse("");

After formatting

List persons = new ArrayList();
String name = persons.stream().filter(x -> "sovan".equals(x.toString())).map(String::toLowerCase).findAny()
				.orElse("");

Is there a way we can stop formatting for this section of code?

Yes!!!

This feature is there only inside our developer tool.. Hidden secret!! HUH!!
Now let this secret revealed..

  • Go to Windows -> Preferences -> Java -> Code Styling -> “Formatter”
  • Click on Edit on the details section. (You can create your own development profile)
  • In the edit section, choose “On/Off tags”.
  • Check “Enable Off/On Tags”. Leave the default @formatteroff and @formatteron or you can rename the tags.
  • Done. Save your profile.

    This slideshow requires JavaScript.

Now wrap your codes around these off and on tag and eclipse will leave that section  untouched while formatting rest of the code.

If you like this post and is helpful, please do leave a comment below. If anyone knows any other better way of doing this, please do share.

Helps the community grow by sharing knowledge.
Happy Coding
Sovan

 

Java 8 – Default Methods in Interface

Java 8 arrived with new features and advances which has also interface with default methods in its arsenal too.

What we might have heard about default methods in interfaces?

  • Multiple inheritance.
  • Backward Compatibility.
  • Default methods reduces the need of abstract class.

While the first two points are correct but the last point is not though it seems to more or less works like the abstract class. I will keep it for last, and starts with some basic information.

Why we needed Default Methods inside Interface?

As it is said, when there are problems we look around for solutions , this is the case where it get fits. Think of a situation where one needs to declare a new method signature inside an interface, and that interface has been implemented in 100’s of classes.  Hhhuh!! That is a painful task as first it is mandatory to  implement it all the the new method in 100 instances and also we need to handle the situation where we don’t need that function.

What if we are allowed to write a default method definition inside interface?
Listen behind, someone whispering “Java 8 allows you to do so…

Continue reading

@ConfigurationProperties : Spring Boot’s way of handling properties

Hello coders,

 

We are always in quest of improving something or the other in our lifetime, this urge also fits in for technologies as well. We can see many enhancements and updates on each and every technology so as in our favourite Spring Framework.

Spring has come a long way ahead since its inceptions.. Yes, the latest buzz word is “SPRING BOOT”!! Though it has made a lot of things easier for a developer, but sometime it debatable. In a nutshell, understanding it deeply is a must.

Here, I will be sharing a tiny, may be a tiniest of a configuration annotations @ConfigurationProperties 

We must have used properties files in almost all of our applications. Spring Boot provides a clean and neat way of using it in applications. Instead of writing the long properties name which is very error-prone (we must have spent lot of time debugging and at last it just a spelling mistake of property name).

So, how about creating a class that gets mapped to properties on a file? Isn’t it a neat style?

Let’s get into coding. We used to start with writing the properties first, but here we can start designing a properties in a Class then move to properties file.

Create a class:

package com.pack.subpack.utils.properties;

import java.util.List;
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix="jwt")
public class JwtProperties {

    private String header;
    @NotNull
    private String secret;
    private int expiration;
    private Map <String,String> authorisation;
    private List<String> someProperties;


//... Getters & Setters
}

This class is marked as @Component. Which makes it a candidate for @Autowiring. Also we have used @ConfigurationProperties(prefix=”jwt”), which indicates that this will get mapped to all properties starts with jwt. Lets have an look at the properties file (properties.yaml)

jwt:
  expiration: 604800
  path: auth
  secret: secret
  authorization:
  username: sovanm
  salt: mysecr3t
  some-properties:
    - prop1
    - prop2

Now the mapping is done, but how to use it? This must be simple. Yes you guessed it right. It is simple. Just Inject the Component and enjoy the get methods to get the values.

private JwtProperties jwtProperties;
// Constructor Injection
@Autowired
public JwtTokenUtils(JwtProperties jwtProperties) {
    this.jwtProperties = jwtProperties;
    System.out.println("Secret: " + this.jwtProperties.getSecret());
    System.out.println("SomePropertiesList: " +
           this.jwtProperties.getSomeProperties());
    this.jwtProperties
        .getAuthorization()
        .entrySet()
        .stream()
        .forEach(e-> {
             System.out.println(e.getKey() + " : " + e.getValue());
        });
}

Done! we can now use the properties anywhere in this class. It helps to make our work easier as we all love to use object intelligence rather than writing the string version as

@Value("$(jwt.authorisation)")
private Map authorisations;

Features, that we can take advantages are:

  •  We can use JSR-303 Annotations for validations. (E,g: Used above)
  •  Intelligence available in the properties file.
  • We can load family of properties into separate classes using the appropriate prefix.

There are lots to know..but  I hope, this might help you getting started dealing with properties file in Boot’s way.

Thanks for reading and Happy Coding 🙂

Sovan

Let us start the SPRING…

Hello Again..

It’s coding time now…and let us do some JAVA coding first then we will “Springify” that code using Spring Framework. It is a simple Java program with classes, interface, main class to bring together all classes to work as one application.

What will we do….

I know you guys will be sad because I promise to have some spring codes, but trust me staring with Springs right away will not that interesting…

Some Prerequisite…

  • IDE : I will be using STS. (SpringSource Tool Suite).
  • Knowledge of Java
That’s it for now..
Begin….
Let us create a simple Contact Manager Application.
  • Create a Java Project (File -> New -> Java Project)
  • Create a Package “com.springwelcome.model” and inside that create a class “Contact.java“. Here we are going to define what we need to store in as contacts. It is a simple POJO class with FirstName, LastName and PhoneNumber.
  • Let us now create another package that will contains the method dealing with data for Database Transactions. Here we are not going to use any database instead we will be using List to store information and return to our Service class. 
  • For this create a package “com.springwelcome.repo” and add a new class “AddToContactImplementation.java“. You must be wondering why am I used …Implementation. Yes, I will using an interface. Let me add the code to make it clear. 

  • Here the question arises why are we using interface here, where we can use the class name directly while creating the instance. You are absolutely correct. In future we are going to learn about spring and we are going to convert this application using springs. In Spring we have an important concept “Inversion Of Control”. Lets move into this later….
  • As we have the Data Storage Class A.K.A. DAO (Data Access Object). To know more about  DAO please follow the link. Now let us create the service which will return us the names in the contact. 
  • Let me create a new package and name it as “com.springwelcome.service” and create a new class inside it as well and name it as “ContactService.java“. 
  •  Similarly we will be implementing an interface here as well. 

  • Now we are almost done with all the parts of this application, We just need to bring together all parts into one. Let us create a new class without any package and name it “ContactManagement.java“. This will contain the  entry point for out application. the MAIN class. 

That is it..we are done with a java application which will be SPRINGIFY soon..

    Hoping you get along with this easily…till next time when we will be doing some changes to implement springs…
    Happy coding.. 🙂

    Thanks,

    Sovan

    … Why SPRING ??

    Hello Guys,

    As already mentioned, Spring is very lightweight and to make it more light it runs on a web container like Tomcat, and to make it lighter for developers it simply based on POJO (plain old Java objects). Even one can create a simple application with simple POJO and some spring configurations.

    Springs came to picture as an alternative to the existing Java EJBs due to the fact that EJB applications has huge problem while maintaining, lack for testing functionalists takes away the first and strong line of defense from developers, adding and removing modules into the old application was very very difficult as they are tightly coupled with each others. With these the added pressure of dealing with the complexities in code do not let developers to concentrate on the core business logic.

    Springs provide greats solutions to all these problem…

    • Testability
    • Maintainability
    • Scalebility
    • Handling complexities with ease
    All together, these makes our life easier and force us to fall in love with SPRINGS at first place. We can now concentrate more on the development of application with the business on mind not with the complexities of coding. We can now handle the exceptions while it still in making not at a point where it became a monster and start punching and kicking us with powerful exceptions. 
    From requester’s perspective, when they need something and ask for that they want that need as final product not the steps followed to make it or make it safe or make it better. On this SPRINGS becomes a huge relief for us to provide requester what they need.
    Now aren’t you in LOVE with spring ? I am now for sure as I am sailing ahead and much interested to get into it ASAP. I know you too and want to see some codes. For us life without codes are boring.

    I promise in coming series will try to get started with our first application…

    Thank you,
    Sovan Misra
     

    How SPRING ? Why SPRING ?

    Hello Folks,

    Welcome back!! Welcome aboard !!

    Just to shake your brains, lets have a recap of the what I am doing here…

    My plan is to “KnowMore” about Springs Framework and share my understanding and gain knowledge from experts and gurus on my way. Its as simple as that.

    But before I start understanding the core, thought to know HOW springs came into existence and WHY it is still so lovable for developers across the world ?? Any guesses..?

    No..!! Yes..!! Its a framework..!! Easy to write code..!! Easy to build application..!!
    Yes, Exactly.

    Before I start sharing the WHY it still the “Love Of Developers”, allow me to explain in brief HOW it came up ?

    Before 2002, we have JAVA EJB,  EE Applications which were in market for quite a long time. But with evolution of developers, so evolve spring as a product which is very LIGHTWEIGHT and runs on a web container e.g TOMCAT not in application server, Simple java POJO based development(I hope that all Java geeks will be here on board…)

    First milestone release came in 2003, then on an average of 15-18 months, springs upgrade itself..with 2004 comes the Spring 1.0 version. By 2006 it releases Spring 1.2.6 and by fall of 2006 Spring 2.0 was released. About 8 months later spring 2.5 was released with a enhancement of using Annotation for configuration and XML configuration (please wait it is coming in soon). This trend move on with 3.0 in 2009 and the current stable version is 4.0 which supports Java SE 8, Groovy 2, and whole lot of things…

    Now WHY ?

    Well!! I keep it to the next in this series…

    Thanks for being with me..

    Sovan Misra