17 min read

In this article by Jérôme Jaglale, author of the book Spring Cookbook , we will cover the following recipes:

    • Installing Java, Maven, Tomcat, and Eclipse on Mac OS
    • Installing Java, Maven, Tomcat, and Eclipse on Ubuntu
    • Installing Java, Maven, Tomcat, and Eclipse on Windows
    • Creating a Spring web application
    • Running a Spring web application
    • Using Spring in a standard Java application

(For more resources related to this topic, see here.)

Introduction

In this article, we will first cover the installation of some of the tools for Spring development:

  • Java: Spring is a Java framework.
  • Maven: This is a build tool similar to Ant. It makes it easy to add Spring libraries to a project. Gradle is another option as a build tool.
  • Tomcat: This is a web server for Java web applications. You can also use JBoss, Jetty, GlassFish, or WebSphere.
  • Eclipse: This is an IDE. You can also use NetBeans, IntelliJ IDEA, and so on.

Then, we will build a Springweb application and run it with Tomcat.

Finally, we’ll see how Spring can also be used in a standard Java application (not a web application).

Installing Java, Maven, Tomcat, and Eclipse on Mac OS

We will first install Java 8 because it’s not installed by default on Mac OS 10.9 or higher version. Then, we will install Maven 3, a build tool similar to Ant, to manage the external Java libraries that we will use (Spring, Hibernate, and so on). Maven 3 also compiles source files and generates JAR and WAR files. We will also install Tomcat 8, a popular web server for Java web applications, which we will use throughout this book. JBoss, Jetty, GlassFish, or WebSphere could be used instead. Finally, we will install the Eclipse IDE, but you could also use NetBeans, IntelliJ IDEA, and so on.

How to do it…

Install Java first, then Maven, Tomcat, and Eclipse.

Installing Java

  1. Download Java from the Oracle website http://oracle.com. In the Java SE downloads section, choose the Java SE 8 SDK. Select Accept the License Agreement and download the Mac OS X x64 package. The direct link to the page is http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html.

    Spring Cookbook

  2. Open the downloaded file, launch it, and complete the installation.
  3. In your ~/.bash_profile file, set the JAVA_HOME environment variable. Change jdk1.8.0_40.jdk to the actual folder name on your system (this depends on the version of Java you are using, which is updated regularly): 
    export JAVA_HOME="/Library/Java/JavaVirtualMachines/ jdk1.8.0_40.jdk/Contents/Home"
  4. Open a new terminal and test whether it’s working: 
    $ java -version
    java version "1.8.0_40"
    Java(TM) SE Runtime Environment (build 1.8.0_40-b26)
    Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)

Installing Maven

  1. Download Maven from the Apache website http://maven.apache.org/download.cgi. Choose the Binary zip file of the current stable version:

    Spring Cookbook

  2. Uncompress the downloaded file and move the extracted folder to a convenient location (for example, ~/bin).
  3. In your ~/.bash_profile file, add a MAVEN HOME environment variable pointing to that folder. For example: 
    export MAVEN_HOME=~/bin/apache-maven-3.3.1
  4. Add the bin subfolder to your PATH environment variable: 
    export PATH=$PATH:$MAVEN_HOME/bin
  5. Open a new terminal and test whether it’s working: 
    $ mvn –v
    Apache Maven 3.3.1 (12a6b3...
    Maven home: /Users/jerome/bin/apache-maven-3.3.1
    Java version: 1.8.0_40, vendor: Oracle Corporation
    Java home: /Library/Java/JavaVirtualMachines/jdk1.8.0_...
    Default locale: en_US, platform encoding: UTF-8
    OS name: "mac os x", version: "10.9.5", arch... …

Installing Tomcat

  1. Download Tomcat from the Apache website http://tomcat.apache.org/download-80.cgi and choose the Core binary distribution.

    Spring Cookbook

  2. Uncompress the downloaded file and move the extracted folder to a convenient location (for example, ~/bin).
  3. Make the scripts in the bin subfolder executable: 
    chmod +x bin/*.sh
  4. Launch Tomcat using the catalina.sh script: 
    $ bin/catalina.sh run
    Using CATALINA_BASE:   /Users/jerome/bin/apache-tomcat-7.0.54
    ...
    INFO: Server startup in 852 ms
  5. Tomcat runs on the 8080 port by default. In a web browser, go to http://localhost:8080/ to check whether it’s working.

Installing Eclipse

  1. Download Eclipse from http://www.eclipse.org/downloads/. Choose the Mac OS X 64 Bit version of Eclipse IDE for Java EE Developers.

    Spring Cookbook

  2. Uncompress the downloaded file and move the extracted folder to a convenient location (for example, ~/bin).
  3. Launch Eclipse by executing the eclipse binary: 
    ./eclipse

There’s more…

Tomcat can be run as a background process using these two scripts:

bin/startup.sh
bin/shutdown.sh

On a development machine, it’s convenient to put Tomcat’s folder somewhere in the home directory (for example, ~/bin) so that its contents can be updated without root privileges.

Installing Java, Maven, Tomcat, and Eclipse on Ubuntu

We will first install Java 8. Then, we will install Maven 3, a build tool similar to Ant, to manage the external Java libraries that we will use (Spring, Hibernate, so on). Maven 3 also compiles source files and generates JAR and WAR files. We will also install Tomcat 8, a popular web server for Java web applications, which we will use throughout this book. JBoss, Jetty, GlassFish, or WebSphere could be used instead. Finally, we will install the EclipseIDE, but you could also use NetBeans, IntelliJ IDEA, and so on.

How to do it…

Install Java first, then Maven, Tomcat, and Eclipse.

Installing Java

  1. Add this PPA (Personal Package Archive): 
    sudo add-apt-repository -y ppa:webupd8team/java
  2. Refresh the list of the available packages: 
    sudo apt-get update
  3. Download and install Java 8: 
    sudo apt-get install –y oracle-java8-installer
  4. Test whether it’s working: 
    $ java -version
    java version "1.8.0_40"
    Java(TM) SE Runtime Environment (build 1.8.0_40-b25)...
    Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25…

Installing Maven

  1. Download Maven from the Apache website http://maven.apache.org/download.cgi. Choose the Binary zip file of the current stable version:

     

  2. Uncompress the downloaded file and move the resulting folder to a convenient location (for example, ~/bin).
  3. In your ~/.bash_profile file, add a MAVEN HOME environment variable pointing to that folder. For example:

    export MAVEN_HOME=~/bin/apache-maven-3.3.1

  4. Add the bin subfolder to your PATH environment variable:

    export PATH=$PATH:$MAVEN_HOME/bin

  5. Open a new terminal and test whether it’s working: 
    $ mvn –v
    Apache Maven 3.3.1 (12a6b3...
    Maven home: /home/jerome/bin/apache-maven-3.3.1
    Java version: 1.8.0_40, vendor: Oracle Corporation
    ...

Installing Tomcat

  1. Download Tomcat from the Apache website http://tomcat.apache.org/download-80.cgi and choose the Core binary distribution.

     Spring Cookbook

  2. Uncompress the downloaded file and move the extracted folder to a convenient location (for example, ~/bin).
  3. Make the scripts in the bin subfolder executable: 
    chmod +x bin/*.sh
  4. Launch Tomcat using the catalina.sh script: 
    $ bin/catalina.sh run
Using CATALINA_BASE:   /Users/jerome/bin/apache-tomcat-7.0.54
...
INFO: Server startup in 852 ms
  5. Tomcat runs on the 8080 port by default. Go to http://localhost:8080/ to check whether it’s working.

Installing Eclipse

  1. Download Eclipse from http://www.eclipse.org/downloads/. Choose the Linux 64 Bit version of Eclipse IDE for Java EE Developers.

     

  2. Uncompress the downloaded file and move the extracted folder to a convenient location (for example, ~/bin).
  3. Launch Eclipse by executing the eclipse binary: 
    ./eclipse

There’s more…

Tomcat can be run as a background process using these two scripts:

bin/startup.sh
bin/shutdown.sh

On a development machine, it’s convenient to put Tomcat’s folder somewhere in the home directory (for example, ~/bin) so that its contents can be updated without root privileges.

Installing Java, Maven, Tomcat, and Eclipse on Windows

We will first install Java 8. Then, we will install Maven 3, a build tool similar to Ant, to manage the external Java libraries that we will use (Spring, Hibernate, and so on). Maven 3 also compiles source files and generates JAR and WAR files. We will also install Tomcat 8, a popular web server for Java web applications, which we will use throughout this book. JBoss, Jetty, GlassFish, or WebSphere could be used instead. Finally, we will install the Eclipse IDE, but you could also use NetBeans, IntelliJ IDEA, and so on.

How to do it…

Install Java first, then Maven, Tomcat, and Eclipse.

Installing Java

  1. Download Java from the Oracle website http://oracle.com. In the Java SE downloads section, choose the Java SE 8 SDK. Select Accept the License Agreement and download the Windows x64 package. The direct link to the page is http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html.

     Spring Cookbook

  2. Open the downloaded file, launch it, and complete the installation.
  3. Navigate to Control Panel | System and Security | System | Advanced system settings | Environment Variables….
  4. Add a JAVA_HOME system variable with the C:Program FilesJavajdk1.8.0_40 value. Change jdk1.8.0_40 to the actual folder name on your system (this depends on the version of Java, which is updated regularly).

    Spring Cookbook

  5. Test whether it’s working by opening Command Prompt and entering java –version.

    Spring Cookbook

Installing Maven

  1. Download Maven from the Apache website http://maven.apache.org/download.cgi. Choose the Binary zip file of the current stable version:

     Spring Cookbook

  2. Uncompress the downloaded file.
  3. Create a Programs folder in your user folder.
  4. Move the extracted folder to it.
  5. Navigate to Control Panel | System and Security | System | Advanced system settings | Environment Variables….
  6. Add a MAVEN_HOME system variable with the path to the Maven folder. For example, C:UsersjeromeProgramsapache-maven-3.2.1.
  7. Open the Path system variable.
  8. Append ;%MAVEN_HOME%bin to it.

     Spring Cookbook

  9. Test whether it’s working by opening a Command Prompt and entering mvn –v.

     Spring Cookbook

Installing Tomcat

  1. Download Tomcat from the Apache website http://tomcat.apache.org/download-80.cgi and choose the 32-bit/64-bit Windows Service Installer binary distribution.

     Spring Cookbook

  2. Launch and complete the installation.
  3. Tomcat runs on the 8080 port by default. Go to http://localhost:8080/ to check whether it’s working.

Installing Eclipse

  1. Download Eclipse from http://www.eclipse.org/downloads/. Choose the Windows 64 Bit version of Eclipse IDE for Java EE Developers.

     Spring Cookbook

  2. Uncompress the downloaded file.
  3. Launch the eclipse program.

Creating a Spring web application

In this recipe, we will build a simple Spring web application with Eclipse. We will:

    • Create a new Maven project
    • Add Spring to it
    • Add two Java classes to configure Spring
    • Create a “Hello World” web page

In the next recipe, we will compile and run this web application.

How to do it…

In this section, we will create a Spring web application in Eclipse.

Creating a new Maven project in Eclipse

  1. In Eclipse, in the File menu, select New | Project….
  2. Under Maven, select Maven Project and click on Next >.
  3. Select the Create a simple project (skip archetype selection) checkbox and click on Next >.
  4. For the Group Id field, enter com.springcookbook. For the Artifact Id field, enter springwebapp. For Packaging, select war and click on Finish.

Adding Spring to the project using Maven

Open Maven’s pom.xml configuration file at the root of the project. Select the pom.xml tab to edit the XML source code directly. Under the project XML node, define the versions for Java and Spring. Also add the Servlet API, Spring Core, and Spring MVC dependencies:

<properties>
<java.version>1.8</java.version>
<spring.version>4.1.5.RELEASE</spring.version>
</properties>
 
<dependencies>
<!-- Servlet API -->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.1.0</version>
   <scope>provided</scope>
</dependency>
 
<!-- Spring Core -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>${spring.version}</version>
</dependency>
 
<!-- Spring MVC -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>${spring.version}</version>
</dependency>
</dependencies>

Creating the configuration classes for Spring

  1. Create the Java packages com.springcookbook.config and com.springcookbook.controller; in the left-hand side pane Package Explorer, right-click on the project folder and select New | Package….
  2. In the com.springcookbook.config package, create the AppConfig class. In the Source menu, select Organize Imports to add the needed import declarations: 
    package com.springcookbook.config;
@Configuration
@EnableWebMvc
@ComponentScan (basePackages = {"com.springcookbook.controller"})
public class AppConfig {
}
  3. Still in the com.springcookbook.config package, create the ServletInitializer class. Add the needed import declarations similarly: 
    package com.springcookbook.config;
 
public class ServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
   @Override
   protected Class<?>[] getRootConfigClasses() {
       return new Class<?>[0];
   }
  
   @Override
   protected Class<?>[] getServletConfigClasses() {
       return new Class<?>[]{AppConfig.class};
   }
 
   @Override
   protected String[] getServletMappings() {
       return new String[]{"/"};
   }
}

Creating a “Hello World” web page

In the com.springcookbook.controller package, create the HelloController class and its hi() method:

@Controller
public class HelloController {
@RequestMapping("hi")
@ResponseBody
public String hi() {
     return "Hello, world.";
}
}

How it works…

This section will give more you details of what happened at every step.

Creating a new Maven project in Eclipse

The generated Maven project is a pom.xml configuration file along with a hierarchy of empty directories:

pom.xml
src
|- main
   |- java
   |- resources
   |- webapp
|- test
   |- java
   |- resources

Adding Spring to the project using Maven

The declared Maven libraries and their dependencies are automatically downloaded in the background by Eclipse. They are listed under Maven Dependencies in the left-hand side pane Package Explorer.

Tomcat provides the Servlet API dependency, but we still declared it because our code needs it to compile. Maven will not include it in the generated .war file because of the <scope>provided</scope> declaration.

Creating the configuration classes for Spring

AppConfig is a Spring configuration class. It is a standard Java class annotated with:

    • @Configuration: This declares it as a Spring configuration class
    • @EnableWebMvc: This enables Spring’s ability to receive and process web requests
    • @ComponentScan(basePackages = {“com.springcookbook.controller”}): This scans the com.springcookbook.controller package for Spring components

ServletInitializer is a configuration class for Spring’s servlet; it replaces the standard web.xml file. It will be detected automatically by SpringServletContainerInitializer, which is automatically called by any Servlet 3. ServletInitializer extends the AbstractAnnotationConfigDispatcherServletInitializer abstract class and implements the required methods:

    • getServletMappings(): This declares the servlet root URI.
    • getServletConfigClasses(): This declares the Spring configuration classes. Here, we declared the AppConfig class that was previously defined.

Creating a “Hello World” web page

We created a controller class in the com.springcookbook.controller package, which we declared in AppConfig. When navigating to http://localhost:8080/hi, the hi()method will be called and Hello, world. will be displayed in the browser.

Running a Spring web application

In this recipe, we will use the Spring web application from the previous recipe. We will compile it with Maven and run it with Tomcat.

How to do it…

Here are the steps to compile and run a Spring web application:

  1. In pom.xml, add this boilerplate code under the project XML node. It will allow Maven to generate .war files without requiring a web.xml file: 
    <build>
   <finalName>springwebapp</finalName>
<plugins>
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-war-plugin</artifactId>
     <version>2.5</version>
     <configuration>
      <failOnMissingWebXml>false</failOnMissingWebXml>
     </configuration>
   </plugin>
</plugins>
</build>
  2. In Eclipse, in the left-hand side pane Package Explorer, select the springwebapp project folder. In the Run menu, select Run and choose Maven install or you can execute mvn clean install in a terminal at the root of the project folder. In both cases, a target folder will be generated with the springwebapp.war file in it.
  3. Copy the target/springwebapp.war file to Tomcat’s webapps folder.
  4. Launch Tomcat.
  5. In a web browser, go to http://localhost:8080/springwebapp/hi to check whether it’s working.

     Spring Cookbook

How it works…

In pom.xml the boilerplate code prevents Maven from throwing an error because there’s no web.xml file. A web.xml file was required in Java web applications; however, since Servlet specification 3.0 (implemented in Tomcat 7 and higher versions), it’s not required anymore.

There’s more…

On Mac OS and Linux, you can create a symbolic link in Tomcat’s webapps folder pointing to the.war file in your project folder. For example:

ln -s ~/eclipse_workspace/spring_webapp/target/springwebapp.war ~/bin/apache-tomcat/webapps/springwebapp.war

So, when the.war file is updated in your project folder, Tomcat will detect that it has been modified and will reload the application automatically.

Using Spring in a standard Java application

In this recipe, we will build a standard Java application (not a web application) using Spring. We will:

    • Create a new Maven project
    • Add Spring to it
    • Add a class to configure Spring
    • Add a User class
    • Define a User singleton in the Spring configuration class
    • Use the User singleton in the main() method

How to do it…

In this section, we will cover the steps to use Spring in a standard (not web) Java application.

Creating a new Maven project in Eclipse

  1. In Eclipse, in the File menu, select New | Project….
  2. Under Maven, select Maven Project and click on Next >.
  3. Select the Create a simple project (skip archetype selection) checkbox and click on Next >.
  4. For the Group Id field, enter com.springcookbook. For the Artifact Id field, enter springapp. Click on Finish.

Adding Spring to the project using Maven

Open Maven’s pom.xml configuration file at the root of the project. Select the pom.xml tab to edit the XML source code directly. Under the project XML node, define the Java and Spring versions and add the Spring Core dependency:

<properties>
<java.version>1.8</java.version>
<spring.version>4.1.5.RELEASE</spring.version>
</properties>
 
<dependencies>
<!-- Spring Core -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>${spring.version}</version>
</dependency>
</dependencies>

Creating a configuration class for Spring

  1. Create the com.springcookbook.config Java package; in the left-hand side pane Package Explorer, right-click on the project and select New | Package….
  2. In the com.springcookbook.config package, create the AppConfig class. In the Source menu, select Organize Imports to add the needed import declarations: 
    @Configuration
public class AppConfig {
}

Creating the User class

Create a User Java class with two String fields:

public class User {
private String name;
private String skill;
public String getName() {
   return name;
}
public void setName(String name) {
 this.name = name;
}
public String getSkill() {
   return skill;
}
public void setSkill(String skill) {
   this.skill = skill;
}
}

Defining a User singleton in the Spring configuration class

In the AppConfig class, define a User bean:

@Bean
public User admin(){
   User u = new User();
   u.setName("Merlin");
   u.setSkill("Magic");
   return u;
}

Using the User singleton in the main() method

  1. Create the com.springcookbook.main package with the Main class containing the main() method: 
    package com.springcookbook.main;
public class Main {
public static void main(String[] args) {
}
}
  2. In the main() method, retrieve the User singleton and print its properties: 
    AnnotationConfigApplicationContext springContext = new AnnotationConfigApplicationContext(AppConfig.class);
 
User admin = (User) springContext.getBean("admin");
 
System.out.println("admin name: " + admin.getName());
System.out.println("admin skill: " + admin.getSkill());
 
springContext.close();
  3. Test whether it’s working; in the Run menu, select Run.

     Spring Cookbook

How it works…

We created a Java project to which we added Spring. We defined a User bean called admin (the bean name is by default the bean method name).

In the Main class, we created a Spring context object from the AppConfig class and retrieved the admin bean from it. We used the bean and finally, closed the Spring context.

Summary

In this article, we have learned how to install some of the tools for Spring development. Then, we learned how to build a Springweb application and run it with Tomcat. Finally, we saw how Spring can also be used in a standard Java application.

Packt

LEAVE A REPLY

Please enter your comment!
Please enter your name here