One of the common use cases for accessing Git repositories on Github is authentication via SSH keys. This offers a secure way of working with Github repositories using SSH protocol.

If you use Eclipse IDE for development and want to use the same for Git workflows like ‘commit’, ‘pull’, ‘push’ etc. you can easily do so by installing one of the Git plugins for Eclipse for example ‘EGit’. By default Eclipse (EGit) would prompt you for username/password while doing Git workflows like ‘push’, you also have the option to save your Git credentials within Eclipse so you don’t have to provide your credentials every time.

However, if you use SSH keys for Git workflows rather than username/password, here is how you can add SSH keys to Eclipse so Eclipse does not prompt you for credentials while doing Git workflows.

Open Eclipse Preferences

Open the Eclipse Preferences via Window > Preferences

Navigate to SSH Preferences

Now type in ‘SSH’ in the search box on the ‘Preferences’ window

Open General SSH2 Settings

Click on ‘SSH’ under, General > Network Connections > SSH2 and open Tab named ‘General’

Set SSH Home Location

On the SSH preferences window, check that you have correctly set your ‘SSH2 Home’ location (path).

Assuming you have local Git installation on your system, the standard path to .ssh home would usually be ‘.ssh’ folder in the user home directory e.g <userhome>/<.ssh>

In case you store your keys somewhere else other than the standard SSH home then you can specify that location as path to SSH home.

Set SSH Private Key/s

While on the SSH window, now click on the ‘Add Private Key’ button and browse to the location of your SSH private key and select your SSH key.

You can specify/load multiple SSH keys using this window separated by commas.

Click Apply to save your changes.

Set/Verify Authentication Method

Next, while on the SSH preferences window, select the tab named ‘Authentication Methods’ and make sure you select/check the ‘publickey’ option. Click Apply to save your changes.

Optional: Save SSH Key ‘Passphrase’ in Secure Store

If you have a ‘passphrase’ (password) set on your SSH key then you also have the option to save your passphrase in Secure Store using Eclipse. If you save your passphrase using this option then Eclipse would not prompt you for a passphrase while doing Git workflows.

For storing your passphrase within Eclipse Secure Store, type ‘Git’ in the search box on the ‘Preferences’ window and navigate to Version Control (Team) > Git and select (check) the option ‘Store SSH Key Passphrase in secure store’

Click Apply and Close to save your changes. DONE!

The post How To Add SSH Private Keys to Eclipse appeared first on Automation Dojos.

This article shows how to change the Package Explorer text size and style.

The font used for tree and table views can now be customized with a font preference. This preference is called “Tree and Table font for views” and can be found in Window > Preferences > General > Appearance > Colors and Fonts under the “View and Editor Folders” category.

Open Eclipse Preferences

Open the Eclipse Preferences via Window > Preferences

Navigate to Colors and Fonts

Navigate to ‘Colors and Fonts’ on the left-hand side preferences tree view

View and Editor Folders Settings

On the right-hand side pane, scroll and locate ‘View and Editor Folders’

Tree and Table Font Views

Scroll down to ‘Tree and Table Font Views’ under ‘View and Editor Folders’

Edit and Set Desired font and styling

Click Apply and Close to Save your Settings. DONE!

Re-launch the Eclipse if your changes are not visible.

The post How To Change Font for Eclipse Package Explorer appeared first on Automation Dojos.

Maven Basics

Maven automates the steps involved in building a software application like adding the JAR files, compiling code, running unit tests, creating the output jar/war file, etc. This makes the code less error-prone. Maven uses an XML configuration file known as the POM file. Developers need to specify information like the JAR files required by an application, the type of output artifact (jar,war, etc). Maven then uses the instructions in the POM file to build the application.

Eclipse Maven Integration

Most of the recent Eclipse releases already include Maven. So, developers do not need to do anything special to install Maven in Eclipse.  However, some earlier versions of Eclipse do not include Maven, so it needs to be installed explicitly from the Eclipse marketplace. Once Maven is set up with Eclipse, it allows you to easily create a Maven project and use all the Maven features like dependency resolution within Eclipse itself.

Create Maven Project with Archetype in Eclipse

Maven archetype provides a template that can be used to create a particular type of Maven project. If a Maven project is created with an archetype selection, Maven creates the POM file accordingly. Some of the common Maven archetypes are as follows:

In order to create a Maven project with a webapp archetype, the following steps need to be followed:

Create new artefact of type ‘Other’

On Eclipse main menu, navigate to ‘File > New’ and select ‘Other’

Select Maven Project

Select the option ‘Maven Project’ and click Next.

Uncheck ‘Create Simple Project‘

Leave the Create a Simple Project (skip archetype selection) checkbox unchecked. Click Next

Use filter ‘maven-archetype-webapp‘

Select maven-archetype-webapp.

Input Group Id and Artifact Id

Enter a value for Group Id and Artifact Id. Change version and package if required. Click Finish

Verify New Maven project in Eclipse

This creates a Maven project in Eclipse with the Maven directory structure and POM file as follows

Finish!

Finish! This POM file can then be modified by adding dependencies and other information as required.

The post How To Create Maven Project in Eclipse With Archetype appeared first on Automation Dojos.

This article shows how to change the text size and style for the Eclipse editor pane.

The font used for Eclipse editor pane can be customized with font preference. This preference is located under “Basic” settings and can be found in Window > Preferences > General > Appearance > Colors and Fonts.

Open Eclipse Preferences

Open the Eclipse Preferences via Window > Preferences

Navigate to Colors and Fonts

Navigate to ‘Colors and Fonts’ on the left-hand side preferences tree view

Basic Color and Font Settings

On the right-hand side pane, scroll and locate ‘Basic’

Text Font Settings

Scroll down to ‘Text Font’ under ‘Basic’

Edit and Set Desired font and styling

Click Apply and Close to Save your Settings. DONE!

Re-launch the Eclipse if your changes are not visible.

The post How To Change Font for Eclipse Editor Pane appeared first on Automation Dojos.

Maven is a very popular build and dependency management tool. Eclipse is an IDE that helps developers write and run Java code easily. In this article, I will be explaining how you can create a Maven project in Eclipse.

Maven Basics

Maven automates the steps involved in building a software application like adding the JAR files, compiling code, running unit tests, creating the output jar/war file, etc. This makes the code less error-prone. Maven uses an XML configuration file known as the POM file. Developers need to specify information like the JAR files required by an application, the type of output artifact (jar,war, etc). Maven then uses the instructions in the POM file to build the application.

Eclipse Maven Integration

Most of the recent Eclipse releases already include Maven. So, developers do not need to do anything special to install Maven in Eclipse.  However, some earlier versions of Eclipse do not include Maven, so it needs to be installed explicitly from the Eclipse marketplace. Once Maven is set up with Eclipse, it allows you to easily create a Maven project and use all the Maven features like dependency resolution within Eclipse itself.

Creating a Simple Maven Project

In order to create a simple Maven project in Eclipse, the following steps need to be followed:

Create new artefact of type ‘Other’

From menu File > New select ‘Other’

Select Maven Project. Click Next

On the ‘new project’ wizard select ‘Maven Project’

Select ‘Create a Simple Project’

Click the Create a Simple Project (skip archetype selection) checkbox. Click Next

Enter value for Group Id & Artifact Id.

Change version and packaging

Change version and packaging if required (This is an optional step). Click Finish

New Maven Project Created

This creates a Maven project in Eclipse with the Maven directory structure and POM file as follows

View Your POM File

The default POM created has the group id, artifact id, version and packaging specified at the time of creation as follows

Finish!

This POM file can then be modified by adding dependencies and other information as required.

The post How To Create Maven Project in Eclipse Without Archetype appeared first on Automation Dojos.

Table of Contents

• 1. What is Maven
• 2. How Maven Works
• 3. Convention over Configuration
• 4. Maven Coordinates
• 5. POM File
  • 5.1. Super POM
  • 5.2. Effective POM
• 6. Maven Directory Structure
• 7. Maven Build Life Cycle
• 8. Dependency Management
  • (8.1) Transitive Dependencies
  • (8.2) Dependencies and Scope
• 9. Running Maven
• 10. Conclusion

1. What is Maven

When you write a software application, there are many steps in it like adding the necessary JAR files, compiling the source code, running unit tests, creating the output jar/war file, etc.

This is where Maven comes into play, it automates the build process, dependency management, testing, packaging, and much more. It allows executing all these steps via simple pre-defined Maven commands thereby reducing human intervention and making the code less error-prone.

On a high-level Maven caters for following aspects of dev project:

2. How Maven Works

The central concept in a Maven project is the POM file. In the POM file, developers need to specify how to configure, build and run an application. In addition, Maven provides build life cycles which consist of build phases and goals.  

Developers need to specify the phase or goal that needs to be executed. Maven then uses these instructions specified in the POM file to execute the specified phase or goal.

3. Convention over Configuration

Maven is based on the principle of ‘Convention over Configuration’ that keeps various project aspects and features standardized and systematic across all Maven projects. Thus, you can achieve consistent project aspects with little or even no configuration.

These so-called ‘Conventions’ are based on best practices and backed up by reasonable defaults. An example of such a ‘convention’ in Maven would be the project directory structure. By default, Maven expects to find all main Java source code under “src/main/java” folder of your project and always looks at this path. Of course, you can override such defaults by customizing your configuration in POM file.

4. Maven Coordinates

Maven coordinates are a set of identifiers that can be used to uniquely identify a project, a dependency, or a plugin in a Maven POM.  All Maven project uses the groupId, artifactId, version, and the packaging property to uniquely identify every Maven component.

The full Maven coordinates are often written in the following format:

groupId:artifactId:packaging:version

5. POM File

The POM stands for Project Object Model. It is a declarative style, XML-based configuration file containing all the information required to build a project or even multiple projects.

Hence every project has its own POM file which is generally located in the root of the source code directory. In the case of multiple projects, a pom file is placed in the root of the source code directory and lists the individual projects as modules.

The following are the main elements in the POM file:

• Group Id/Artifact Id/Version (GAV) – These elements help to uniquely identify a project
• Packaging – This specifies the type of the output file like jar, war, etc.
• Dependencies – This specifies the external dependencies or jar files that an application requires. Maven automatically downloads the jar files specified here from a central repository
• Build – This specifies information like the goal to run by default if one is not explicitly specified, the directory where to place the output artifact, plugin information, etc.

Here is an example of a very simple POM file:

<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.abc.xyz</groupId>
  <artifactId>HibernateApp</artifactId>
  <version>1</version>
  <dependencies>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-core</artifactId>
  		<version>5.3.4.Final</version>
  	</dependency>
  	<dependency>
  		<groupId>mysql</groupId>
  		<artifactId>mysql-connector-java</artifactId>
  		<version>8.0.12</version>
  	</dependency>
  </dependencies>
</project>

The POM file above specifies the group id as com.abc.xyz, artifact id as HibernateApp and version as 1. In the dependencies section, it specifies the dependencies for Hibernate and the MySQL JDBC driver.

5.1. Super POM

All POMs inherit from a parent or default POM whether explicitly defined or not. In cases where no explicit parent POM is defined, it inherits from the default or base pom of Maven.

In relation to POM, Maven has the concept of ‘Super POM’ which is considered as Maven’s default POM or base POM. This ‘Super POM’ defines all default settings, which are automatically inherited by all Maven projects by ‘Inheritance’. This is one of the strategies by which ‘Convention over Configuration’ manifests in Maven.

Under the inherited Super POM, each individual project implements its own local project POM (also Known as Simplest POM) providing its own unique information specific to that project including any overrides in that project’s POM file thereby achieving a project-specific and customized project POM.

5.2. Effective POM

Maven always executes against an effective pom. This is an amalgamation or combination of settings from this project’s pom.xml, all parent pom (if declared), a super-pom, user-defined settings, and active profiles settings.

This helps developers to specify minimum configuration detail in their Project POM while re-using the inherited default POM. You can see your effective POM by using the following command:

mvn help:effective-pom

6. Maven Directory Structure

Maven defines a standard directory structure and always looks for these directories by default. Although you can certainly override or customize this directory structure via your POM configuration but by default Maven expects developers to follow this directory structure:

7. Maven Build Life Cycle

A build life cycle refers to a set of steps that are executed sequentially as part of a Maven build. Maven has 3 built in build lifecycles as follows:

Each build lifecycle consists of a number of phases.

8. Dependency Management

In Maven, you just declare the external dependency in the dependencies section of the POM file.  These dependencies could be a library, package, or plugin (mostly in the form of ‘.jars’) that is needed for your project. Then, Maven will automatically download these dependencies and any transitive dependencies along with them. Maven will recursively resolve any required dependencies for your project.

All dependencies are downloaded from Maven repositories defined. But dependencies downloaded from the internet are stored locally as well in a local Maven repository like a local dependency cache. Hence Maven looks at the local repository first, for any dependencies, before going out to the internet for download.

This local Maven repository is a folder called .m2/repository in the home directory. When a Maven build is run, it first checks if the jar files corresponding to the dependencies in the POM file are present in the local repository. If so, it uses them. If not, it downloads the JAR files from the Maven Central repository. 

Maven Central repository is a repository of a large number of JAR files that is maintained by the Maven community. Developers can also configure an alternate repository in the POM file. Downloaded JAR files are placed in the local repository.

(8.1) Transitive Dependencies

A transitive dependency is basically the dependency of your dependency, for example, you could be using a java library or package which could be dependent on another package which in turn could be dependent on another one, and so on. Such indirect dependencies are called ‘Transitive Dependencies’.

One of the best features of Maven is automatically taking care of transitive dependencies which in some cases could prove very painful especially when there is a chain of transitive dependencies for a project.

(8.2) Dependencies and Scope

Finally, dependencies can be bound to a specific scope, which defines when and where the dependencies are needed in your project. For example, the TestNG, JUint jars are needed for Testing, but they are not needed for deployment to an application server. Hence they will be bound to ‘Test’ phase rather then build or other phases.

You can use the following command to print ‘dependencies’ for your project:

mvn dependency:tree

The above command will first of all download Maven plugin called ‘maven-dependency-plugin’ and then print dependencies for your project.

9. Running Maven

In order to run Maven, developers need to specify the Maven command (mvn).  Along with the mvn command, the build phase/goal can also be specified.

First of all, Maven resolves the dependencies specified in the dependencies section. After that, Maven runs the specified goals/phase. If a phase is specified, Maven sequentially executes all the phases before the specified phase.

If developers do not specify a phase or goal along with the mvn command, the value specified under build/defaultGoal will be used. If this value is not specified, an error will occur. Also, the type of output artifact to be produced (specified in the packaging element), determines which goals will be executed as part of a phase.

10. Conclusion

So, to summarise, Maven is a dependency management tool that helps to configure, build and run an application. It uses an XML configuration file known as the POM file. It also follows a certain life cycle that consists of phases and goals. It executes the specified phases and goals as part of the build process.

The post Introduction to Apache Maven appeared first on Automation Dojos.