DZone is proud to present this complete overhaul and update of the most popular article ever written on Javalobby. Previously titled "Spring IDE - Using Spring in Eclipse," this article from 2008 is still one of the highest ranked pages on Google from DZone. Originally written by Javalobby Zone Leader, James Sugrue, this article has been mostly rewritten by Martin Lippert, a developer in the SpringSource tools division. Enjoy the 2014 version!
This article is an introduction to Spring IDE and the Spring Tool Suite – a set of plugins to simplify the development of Spring-based applications in Eclipse. Let’s start by looking at the Spring Framework and how we can use it to write a few simple Spring applications.
Spring in a Nutshell
For a concise introduction to Spring, read the reference documentation for Spring 4. It contains a nice introduction to the core concepts as well as a comprehensive overview and in-depth look at all of the various features that come with the latest version of the Spring core framework. In addition to the core framework, the Spring IO platform documentation gives you an additional overview about how to use both the execution layer and the foundation layer components to build modern enterprise applications.
In the simplest terms, Spring allows you to build an application using Plain Old Java Objects (POJO's) and dependency injection, which helps you wire up the different components of your application. Most people prefer to use annotations, or Java Configuration and therefore stay on the pure Java side. You can also use an XML configuration file to 'wire up' your POJOs that act as beans. All of these methods are perfectly fine and supported by Spring.
The components that you define, the Spring beans, can then reside in the Spring container. In addition to the pure dependency injection mechanism, Spring provides a first-class integration for aspect-oriented programming (AOP) and comes with a huge set of service-level abstractions. Those are ready-to-use bean implementations that encapsulate certain technologies like transactions, persistence technologies, and many more. All this results in a programming model that lets you write your application independent of a concrete technology or a concrete runtime environment for deployment. This is why, many years after its release, Spring probably the most popular framework and environment for implementing Java enterprise applications.
Spring IDE (Eclipse Plug-in)
The Spring IDE is an open-source project that provides a set of plugins for the Eclipse IDE. These plugins make the Eclipse IDE Spring-aware. After installing the Spring IDE plugins, your IDE understands your projects from the perspective of the Spring framework and provides you with a wide variety of additional features that make it easier and more convenient to work with Spring projects in Eclipse.
The IDE provides various wizards for creating Spring projects and getting started with Spring if you’re a beginner. Of course, it can also be used on existing Spring projects. Once you have a project configured to be a Spring project, you can let the IDE know which Spring configuration files your projects uses (either those XML config files or your Spring JavaConfig classes that use the @Configuration annotation). From there on, you can benefit from the Spring-specific tooling support, including:
- Spring-specific content-assist and validation for your spring config files
- Spring-specific refactoring support for your spring config files
- Graphical visualization of your beans and their dependencies
- Graphical diagram-like editors for Spring Integration, Spring Batch, and Spring Webflow
- Advanced support for Spring aspects including pointcut visualization and navigation
- Integration with AJDT and Eclipse Mylyn tooling
- Support for Spring bean profiles and validation inside profiles
- Direct integration of the ‘getting started’ guides from http://spring.io/guides
- A number of example and reference applications to learn from
- Support for creating and using Spring Boot projects right within your IDE
- and more…
The Spring Tool Suite (Full Distribution)
While the Spring IDE project provides a set of plugins for the Eclipse IDE, the Spring Tool Suite comes as a ready-to-use distribution of the latest Eclipse releases with the Spring IDE components pre-installed. This includes the tc Server integration for Eclipse (another IDE extension that is provided by Pivotal as an open-source project) and various other additions to Eclipse that turn the pure Eclipse IDE into a ready-to-use, best-of-breed environment for enterprise Spring application development. To download the Spring Tool Suite, go to: http://spring.io/tools
Lets get Started - Installing the Spring Tooling
There are two ways to get Spring-tooling enabled in Eclipse: Either you download the Spring Tool Suite distribution as a ready-to-use package (recommended) or you download the latest Eclipse JEE package from http://www.eclipse.org/ and start from there. You might also have an existing Eclipse IDE running on your machine that you just want to extend with the Spring tooling. The easiest way to install the Spring tooling into your existing (or freshly downloaded) Eclipse IDE is to go the Eclipse Marketplace and search for the “Spring Tool Suite” - and install from there.
If you would like to use Maven (which is used in many Spring projects) and you haven’t installed the Maven Integration for Eclipse yet, you should go ahead and do that. You can grab it from the Eclipse Marketplace or directly from the main Eclipse update repository, which is pre-configured in your Eclipse IDE. Just look for the “Install New Software” wizard. It is also recommended that you install the Maven Integration for Eclipse WTP, which makes it easy to work with web projects using Maven inside Eclipse. If you decided to download the Spring Tool Suite distribution package, those extensions are already pre-installed for you.
Create a New Project
To create a new project, you just need to use the New Spring Project wizard to get going. If you don't do this, it's ok – you can just add a "Spring Nature" to your project at a later stage.
The wizard provides you with a few options for getting started with a new Spring project. For some of the common use cases, the Spring tooling provides a number of templates, like a simple Spring MVC application or some examples for using Spring Integration, just to name a few. After giving the project a name and selecting the template, the wizard usually allows you to customize a few settings in the project (like the package names). Once that’s done, you are ready to go. This is an easy way to get started with a ready-to-use Spring project that already runs and does something for you.
The simple Spring MVC project example is a very popular one that gets you started with a more classic Spring web application, which includes:
- Traditional Spring XML configurations for the web application
- Component scanning for the controller implementations that use the @RequestMapping annotation in the source code
- A traditional JSP page for the frontend, which is probably similar to the structure of many existing Spring web applications
If you are using the Spring Tool Suite distribution, you get a ready-to-use tc Server instance created and configured in your workspace. It allows you, for example, to deploy and run your freshly created Spring MVC app immediately.
If you would like to start with an empty project instead, you can do that, of course. For this case, there are a few simple templates provided by the wizard that help you do that. If you choose to use Maven for your project build and dependency management, you could choose the simple Maven web template. It doesn’t create any code for you, but it puts all the necessary Spring libraries on the classpath of the project.
If you started with the Spring MVC web application example, some of the features of the Spring tooling will immediately catch your eye. The project explorer gets a new section “Spring”, that shows you the structure and the beans of your Spring applications. Furthermore, it gives you an overview of the annotation-based stereotypes used within your project. In web applications, for example, it gives you a nice overview of the defined @RequestMapping methods with the ability to jump right into the code.
Next Page: Using Spring Boot and the new Getting Started Guides
Using Spring Boot and the new Getting Started Guides
If you’ve seen the new Spring Boot project, then you know how easy it is to get started with Spring using Spring Boot. There is a direct integration for that in the tooling starting in version 3.4.0. You can go ahead and create a new Spring Boot project by selecting the “New -> Spring Started Project”. It will open a simple wizard for you that lets you choose among various options for what to get on the classpath of the new Spring project and it creates a simple main Application class that you could use to startup the application.
Since Spring Boot takes care of starting up an embedded Tomcat instance, you don’t have to deploy your application to a server that you configured inside your IDE anymore. Simply starting the project as a general Java application will work just fine.
In addition to using the very basic (and purist) Spring Boot approach, you could also use the new Getting Started Guides (http://spring.io/guides) directly from within the tooling. To do that, you select the “New -> Import Spring Getting Started Content” wizard and go from there. It lists all the available guides that you can find on the http://spring.io website and lets you import them into your IDE quickly (alongside the documentation inside the IDE using a browser view). This provides you with a nice learning experience when getting started with Spring in general or when diving into certain features of Spring.
Configuring an Existing Project
If you are already a Spring developer and want to benefit from the Spring tooling in your IDE, you will want to enable the tooling for any existing projects in your workspace. Just select your project, open the context menu, and select “Spring Tools -> Add Spring Project Nature”. Once you’ve done that, the IDE treats this project as a Spring project and enables all the Spring-related features for it.
Once the project in Eclipse or the Spring Tool Suite has the Spring nature enabled, you can go ahead and configure the used Spring bean config files. To do that you just go to the project preferences and select “Spring -> Beans Support”.
There you can configure the Spring config files (either the Spring XML config files or the @Configuration classes if you are using the pure annotation-based method). This lets the tooling know about your config files and tells the tools where to start the Spring-specific analysis of your project.
Some of those config files are recognized and configured automatically, since the tooling knows about the usual names and the usual locations for those files (especially for web apps). If they are not showing up automatically, please go ahead and configure them manually (and probably file a bug with the Spring IDE developers to let them improve the automatic discovery of those config files).
Working with the Spring Tooling
The tooling is what makes working with Spring in Eclipse a real pleasure. The Spring explorer view and the corresponding section of the project explorer give you a nice overview of your Spring project, and every time you change your code or your config files, it gets updated. It allows you to quickly navigate to the source code and helps you quickly understand the structure of your Spring project.
The most valuable aspect of the tooling is the support for editing and validating Spring configurations. It doesn’t matter if you use Spring XML config files or if you prefer the annotation-based configuration style. The tooling gives you meaningful content-assist all over the place and assists you with additional, Spring-specific validations that help you identify problems, typos, and other issues as early as possible.
The most comprehensive support is available for working with Spring XML config files. When defining Spring beans in the XML config files, you get content-assist for all kinds of elements, including full assist for typing in the class of a bean, referring to other bean definitions, or referring to a class property in order to inject dependencies.
If a problem appears, the tooling assists you in fixing this problem by providing quick-fix solutions. That makes it easy to add, for example, a missing bean definition or to create a new property in the related Java class, if the config file refers to a missing property.
Validations take care of checking your Spring config files and they make sure that you don’t forget a bean definition. They also points you toward the better options for writing your Spring configs if it detects a common anti-pattern. This is extremely useful for autowired dependencies where you don’t know right away what gets injected at runtime, or whether something exists at runtime that will be injected into an @Autowired field or parameter. The tooling can check this for you and give you a warning if it cannot find anything that could get injected there.
A list of the available validations can be found in the global preferences via “Preferences -> Spring -> Project Validators”. That preference page allows you to enable or disable those validations as well.
Improving the structure of your code is always on your mind if you’re a professional developer, and today’s IDE provide nice refactoring support for these tasks. The Spring tooling, for example, integrates the Spring-specific configuration files into this refactoring support of your IDE. Whenever you rename a class in Eclipse, it gets updated in your Spring config files as well. The same happens if you change the name of a property in your Java class. If there is a reference to this property in one of your Spring config files, it gets updated as well. In addition to that, it also allows you to rename beans themselves via a special “Rename Bean ID” refactoring, changing all references to that bean ID automatically.
This article covers only the basic features and first steps for getting started with the Spring tooling for Eclipse. The tooling provides a lot more functionality than what is mentioned in this article. The graphical views and editors are especially powerful when working with Spring Integration, Spring Batch, and Spring Webflow. And there is more and more support emerging for annotation-based Spring configurations, although the general Java tooling in Eclipse is already extremely useful and supportive for those out-of-the-box.
If you want to learn more about the tooling and see what is new in the latest versions, please take a look at the new and noteworthy documentation that comes with every release:
More information can be found here: