In this tutorial we will create a simple web application using Spring MVC, Hibernate and JSON. We will use Maven to manage dependencies and IntelliJ IDEA to create, run and debug an application on local Tomcat application server.
Wiki Markup |
---|
{redirect:https://www.jetbrains.com/idea/help/spring.html|delay=0} |
Note |
---|
|
Make sure that Spring, Maven and Tomcat plugins are enabled in IntelliJ IDEA Ultimate before you perform this tutorial. |
1. Create a project
Open
span |
---|
|
Project Wizard Wiki Markup |
---|
{span:class=shortcut}Project Wizard{span} |
and select
in span |
---|
|
Spring section Wiki Markup |
---|
{span:class=id}Spring MVC{span} |
in Wiki Markup |
---|
{span:class=id}Spring section{span} |
. If you have already configured
the application server
, you can select it in
the span |
---|
|
Application Server Wiki Markup |
---|
{span:class=id}Application Server{span} |
field. With
IntelliJ IDEA you can deploy applications to
Tomcat,
TomEE,
Glassfish,
JBoss,
WebSphere,
Jetty,
Geronimo,
Resin,
Cloud Foundry and
CloudBees.

Change
, and span |
---|
|
Base package Wiki Markup |
---|
{span:class=id}Project name{span} |
, Wiki Markup |
---|
{span:class=id}Project location{span} |
and Wiki Markup |
---|
{span:class=id}Base package{span} |
if necessary. The IDE will create a
span |
---|
|
"Hello world" Wiki Markup |
---|
{span:class=id}"Hello world"{span} |
project with
a simple controller and view.
...
The new project comes with Maven's
span |
---|
|
Wiki Markup |
---|
{span:class=id}pom.xml{span} |
file. You can manage project dependencies through this file or through the dedicated
span |
---|
|
Maven Wiki Markup |
---|
{span:class=shortcut}Maven{span} |
tool window.

When you change Maven's dependencies, IntelliJ IDEA applies the corresponding changes to the project automatically. You can check it in the
span |
---|
|
Project Structure → Modules Wiki Markup |
---|
{span:class=shortcut}Project Structure → Modules{span} |
dialog.

Just like Besides dependencies, IntelliJ IDEA also imports the artifacts definition from
span |
---|
|
Wiki Markup |
---|
{span:class=id}pom.xml{span} |
file. You can check the artifacts settings in
the span |
---|
|
Project Structure → Artifacts Wiki Markup |
---|
{span:class=shortcut}Project Structure → Artifacts{span} |
dialog.

The artifacts define the structure of what is going to will be deployed to the application server when you click
span |
---|
|
Run Wiki Markup |
---|
{span:class=shortcut}Run → Run 'Tomcat 7.0'{span} |
.
2. Create run configuration
If you haven't specified
in span |
---|
|
Project Wizard Wiki Markup |
---|
{span:class=id}Application server{span} |
in Wiki Markup |
---|
{span:class=shortcut}Project Wizard{span} |
you can do it now via
span |
---|
|
Run → Edit Wiki Markup |
---|
{span:class=shortcut}Run → Edit Configurations...{span} |
.

Don't forget to specify the artifacts to deploy for this run configuration via the
span |
---|
|
Deployment Wiki Markup |
---|
{span:class=shortcut}Deployment{span} |
tab.

If you have configured at least one run configuration for an application server, IntelliJ IDEA shows the
span |
---|
|
Application Servers Wiki Markup |
---|
{span:class=shortcut}Application Servers{span} |
tool window to manage
the application state
of application on the application server. You can see the list of application servers, start or stop servers, see deployed applications, manage artifacts to deploy
, and manage
the application state.

3. Run the application
When After the artifacts and run configurations are defined, you can deploy the application by simply running your configuration or via a shortcut right from the
span |
---|
|
Application Servers Wiki Markup |
---|
{span:class=shortcut}Application Servers{span} |
tool window.

4. Add dependencies
Since we are going to create a database for our application, we need Spring Data, Hibernate and HSQLDB libraries. In order to implement JSON API for our application we need JSON library. And finally Finally, we will need JSTL library to use in application's view.
We have to add define all these dependencies in our
span |
---|
|
Wiki Markup |
---|
{span:class=id}pom.xml{span} |
file. The IDE will automatically download the corresponding libraries and add to the artifact.
...
5. Create persistence.xml
Now let's define
span |
---|
|
Wiki Markup |
---|
{span:class=id}resources/META-INF/persistence.xml{span} |
file to initialize
Hibernate's entity manager over
JPA.
...
Now we have to register the user repository, an entity manager factory and a transaction manager in
span |
---|
|
Wiki Markup |
---|
{span:class=id}webapp/WEB-INF/mvc-dispatcher-servlet.xml{span} |
file.
Code Block |
---|
|
<jpa:repositories base-package="com.springapp.mvc"/>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
<property name="persistenceUnitName" value="defaultPersistenceUnit"/>
</bean>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
|
The model for our application is ready, so we can implement the controller.
8. Define controller
Let's rename
to span |
---|
|
UserController Wiki Markup |
---|
{span:class=id}HelloController{span} |
to Wiki Markup |
---|
{span:class=id}UserController{span} |
and add the following code:
Code Block |
---|
|
package com.springapp.mvc;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class UserController {
@Autowired
private UserRepository userRepository;
@RequestMapping(value = "/", method = RequestMethod.GET)
public String listUsers(ModelMap model) {
model.addAttribute("user", new User());
model.addAttribute("users", userRepository.findAll());
return "users";
}
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String addUser(@ModelAttribute("user") User user, BindingResult result) {
userRepository.save(user);
return "redirect:/";
}
@RequestMapping("/delete/{userId}")
public String deleteUser(@PathVariable("userId") Long userId) {
userRepository.delete(userRepository.findOne(userId));
return "redirect:/";
}
}
|
As you can see, we have defined three methods for listing, adding and deletion deleting user entities. The methods are mapped to the corresponding URLs.
9. Define view
Let's rename
span |
---|
|
hello Wiki Markup |
---|
{span:class=id}hello{span} |
view (and corresponding
span |
---|
|
Wiki Markup |
---|
{span:class=id}hello.jsp{span} |
file) to
span |
---|
|
users Wiki Markup |
---|
{span:class=id}users{span} |
(and
span |
---|
|
Wiki Markup |
---|
{span:class=id}users.jsp{span} |
correspondingly , respectively). If you rename the view name from usage
, IntelliJ IDEA applies
the corresponding changes to JSP files automatically.
Code Block |
---|
|
<!doctype html>
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<meta charset="utf-8">
<title>Spring MVC Application</title>
<meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link href="http://twitter.github.comio/bootstrap/assets/css/bootstrap.css" rel="stylesheet">
<link href="http://twitter.github.comio/bootstrap/assets/css/bootstrap-responsive.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row">
<div class="span8 offset2">
<h1>Users</h1>
<form:form method="post" action="add" commandName="user" class="form-horizontal">
<div class="control-group">
<form:label cssClass="control-label" path="firstName">First Name:</form:label>
<div class="controls">
<form:input path="firstName"/>
</div>
</div>
<div class="control-group">
<form:label cssClass="control-label" path="lastName">Last Name:</form:label>
<div class="controls">
<form:input path="lastName"/>
</div>
</div>
<div class="control-group">
<form:label cssClass="control-label" path="email">Email:</form:label>
<div class="controls">
<form:input path="email"/>
</div>
</div>
<div class="control-group">
<div class="controls">
<input type="submit" value="Add User" class="btn"/>
</form:form>
</div>
</div>
<c:if test="${!empty users}">
<h3>Users</h3>
<table class="table table-bordered table-striped">
<thead>
<tr>
<th>Name</th>
<th>Email</th>
<th> </th>
</tr>
</thead>
<tbody>
<c:forEach items="${users}" var="user">
<tr>
<td>${user.lastName}, ${user.firstName}</td>
<td>${user.email}</td>
<td>
<form action="delete/${user.id}" method="post"><input type="submit" class="btn btn-danger btn-mini" value="Delete"/></form>
</td>
</tr>
</c:forEach>
</tbody>
</table>
</c:if>
</div>
</div>
</div>
</body>
</html>
|
...
If you need to debug your application, just add a breakpoint and re-run the application in debug mode via
span |
---|
|
Run → Debug... Wiki Markup |
---|
{span:class=shortcut}Run → Debug 'Tomcat 7.0'...{span} |
.

12. Add JSON API
And finally Finally, let's output the created users via JSON by implementing this simple Controller's method:
...
Run the application and open http://localhost:8080/api/users.

Info |
---|
|
Download the final code and IntelliJ IDEA's project files from GitHub. |