Fast Track. Evaluation Copy. to Spring 3.x. on Eclipse/Tomcat. LearningPatterns, Inc. Courseware. Student Guide

Transcription

1 Fast Track to Spring 3.x on Eclipse/Tomcat LearningPatterns, Inc. Courseware Student Guide

2 This material is copyrighted by LearningPatterns Inc. This content and shall not be reproduced, edited, or distributed, in hard copy or soft copy format, without express written consent of LearningPatterns Inc. Copyright LearningPatterns Inc. For more information about Java Enterprise Java, or related courseware, please contact us. Our courses are available globally for license, customization and/or purchase. LearningPatterns. Inc. Global Courseware Services Main St. #12 Beacon NY, USA voice and fax Java, and all Java-based trademarks and logo trademarks are registered trademarks of Oracle, Inc., in the United States and other countries. LearningPatterns and its logos are trademarks of LearningPatterns Inc. All other products referenced herein are trademarks of their respective holders.

3 Table of Contents Fast Track to Spring 3.x Fast Track to Spring 3 1 Workshop Overview 2 Workshop Objectives 3 Workshop Agenda 4 Typographic Conventions 5 Labs 6 Release Level 7 Session 1: Introduction to Spring 8 Lesson Objectives 9 Overview 10 The Challenge of Enterprise Applications 11 Shortcomings of Java/Java EE 12 What is Spring? 13 The Spring Modules 14 The Spring Distribution 15 The Spring Distribution 16 Lab 1.1 Setting Up the Environment 17 Spring Introduction 33 Managing Beans 34 A Basic Spring Application 35 Some Bean Classes 36 Configuration Metadata 37 Declaring Beans 38 The Spring Container 39 Working With Spring 40 A Simple Spring Example 41 Why Bother? 42 Some BeanFactory/ApplicationContext API 43 Lab 1.2 Hello Spring World 44 Dependencies and Dependency Injection 49 Dependencies Between Objects 50 Example of a Direct Dependency 51 Dependency Inversion Principal 52 Example of Dependency Inversion 53 Example of Dependency Inversion 54 Dependency Injection (DI) in Spring 55 Dependency Injection Configuration 56 Dependency Injection Example 57 Advantages of Dependency Injection 58 Dependency Injection Reduces Coupling 59 Lab 1.3 Dependency Injection 60 Review Questions 65 Lesson Summary 66 Session 2: More About Bean Properties 68 Lesson Objectives 69 Working with Properties 70 Copyright , LearningPatterns Inc. All rights reserved i

4 Configuring Value Based Properties 71 Using Value Based Properties 72 Property Conversions 73 Constructor Injection 74 Constructor Argument Resolution 75 Constructor Argument Resolution 76 Constructor Argument Resolution 77 XML Shortcuts - p: and c: Namespaces 78 Setter Injection vs. Constructor Injection 79 Setter Injection vs. Constructor Injection 80 Lab 2.1 Spring Configuration 81 Collection Valued Properties 91 Working with Collections 92 Collection Property Example 93 Configuring <list> and <set> Properties 94 Configuring Collection of Bean References 95 Map Valued Properties 96 java.util.properties Valued Properties 97 Lab 2.2 Collection Valued Properties 98 Additional Capabilities Factory Methods Instance Factory Methods Bean Aliases Bean Definition Inheritance Inheritance Example SpEL: Spring Expression Language Other SpEL Capabilities Autowiring Autowiring byname Example 112 Autowiring bytype 113 Pros and Cons of Autowiring 114 To Autowire or Not to Autowire 115 Review Questions 116 Lesson Summary 117 Session 3: The Spring Container and API 119 Lesson Objectives 120 ApplicationContext 121 ApplicationContext Interface 122 ApplicationContext Implementations 123 Constructors 124 Using an ApplicationContext 125 Spring Resource Access 126 Built-in Resource Implementations 127 Lab 3.1 More about ApplicationContexts 128 Bean Scope and Lifecycle 132 Bean Scope 133 Specifying Bean Scope 134 Inner Beans 135 Compound Names 136 Depends On 137 Bean Creation Lifecycle 138 Copyright , LearningPatterns Inc. All rights reserved ii

5 Bean Creation Lifecycle Details 139 Using the Lifecycle Interfaces for Beans 140 Bean Destruction Lifecycle 141 BeanPostProcessor 143 Event Handling 144 Lab 3.2 Bean Lifecycle 145 Annotation Driven Configuration 151 Annotations in Spring 152 Enabling Spring Annotations and Auto-Detecting Beans 154 Annotation-based Bean Definition and DI 155 Complete Declarations Using Annotations 156 XML Config for Annotations and Scanning 157 Other Stereotype Annotations - Additional Uses Examples 161 Qualifiers 162 Lifecycle Annotations 163 Annotation Configuration - Pro / Con 164 A Note on the XML Configuration 165 A Brief Note on Annotations 166 Annotation Definition Example 167 Lab 3.3 Spring Annotations 168 Java-based Configuration 173 Java Configuration Overview 174 Using Java-based Configuration 175 Dependency Injection 176 More on How it Works 177 Dependencies Between Configuration Classes 178 Other Usage Scenarios 179 Classpath Scanning 180 Capabiliites 181 Java-based Configuration - Pro / Con 182 [Optional] Lab 3.4 Java-based Config 183 Maven and Spring 188 About Maven 189 How We'll Work With Maven 190 The POM (Project Object Model) 191 POM - Required Elements 192 POM - External Dependencies 193 Maven Artifacts for Spring 194 Repositories 195 Maven Project Structure 196 Eclipse / Maven Integration 197 The Lab 198 [Optional] Lab 3.5 Using Maven 199 Lab 3.5 Using Maven 200 Review Questions 210 Lesson Summary 211 Copyright , LearningPatterns Inc. All rights reserved iii

6 Session 4: Database Access With Spring 214 Lesson Objectives 215 Overview 216 DAO Support 217 Datasources 218 Configuring the DataSource 219 Looking up a DataSource in JNDI 220 [Optional] Using Spring with Hibernate 221 Hibernate Overview 222 Typical Hibernate Configuration File 223 Using Hibernate Directly 224 Spring Support for Hibernate 225 LocalSessionFactoryBean 226 Configuring a Hibernate Session Factory 227 Contextual Sessions 228 Spring Free DAO 229 What Approach to Use 230 [Optional] Using Spring with JPA 231 Template Support for JPA 232 Managing the EntityManager 233 LocalContainerEntityManagerFactoryBean 234 Container-Managed EntityManager 235 JEE: Obtaining an EntityManager From JNDI 236 LocalEntityManagerFactoryBean 237 Additional Spring Configuration 238 Spring Configuration Example 239 JPA Data Access Object 240 Extended Persistence Context 241 [Optional] Lab 4.1 Integrating Spring and JPA 242 Review Questions 253 Lesson Summary 254 Session 5: Transactions 256 Lesson Objectives 257 Spring Transaction Management 258 Transaction (Tx) Overview 259 Transaction Lifecycle 260 Transaction Managers 261 Configuring Transaction Managers 262 JTA Transaction Manager 263 Spring Declarative Transaction Management 264 Spring Transactional Scope 265 Transaction Propagation 266 Transaction Attributes for Propagation 267 MANDATORY 268 NESTED 269 NEVER 270 NOT_SUPPORTED 271 REQUIRED 272 REQUIRES_NEW 273 SUPPORTS 274 Copyright , LearningPatterns Inc. All rights reserved iv

7 Transaction Example 275 Transaction Attributes Some Choices 276 Transaction Attributes - Some Choices 277 Specifying Transaction Attributes 278 Specifying Transaction Attributes 279 Additional Transactional Attributes 280 Transactional Attributes Guidelines 281 Rolling Back and Exceptions 282 Lab 5.1 Spring Transactions 283 Spring Proxies and Direct Invocation 292 Example Invoking Directly 293 Example Invoking Directly 294 Load-Time Weaving 295 Spring's Load-Time Weaving 296 [Optional] Lab 5.2: Load-Time Weaving 297 [Optional] XML Configuration 302 Specifying Transactions Using XML 303 Spring Transactions and AOP 304 Defining a Pointcut 305 Linking Advice With Pointcuts 306 <tx:method> Attributes 307 Why Use XML Configuration 308 Review Questions 309 Lesson Summary 310 Session 6: Integrating Spring with Java Web Applications 311 Spring and Java EE 312 Web Application Structure 313 ApplicationContext and Java Web Apps 314 Configuring ContextLoaderListener 315 Using the Application Context 316 Lab 6.1 Spring and the Web 317 Lesson Summary 333 [Optional] Session 7: Spring Security Overview 334 Spring Security 335 Spring Web Security - web.xml 336 Spring Web Security - Spring Configuration 337 Spring Web Security - Spring Configuration 338 More <security:http> Capabilities 339 Other User Details Services 340 Lab 7.1 Spring Web Security 341 Method Security 346 Method Security - Annotations 347 Method Security - Pointcut Expressions 348 Method Security - XML Configuration 349 Lab 7.2 Method Security 350 Lab 7.2 Method Security 351 Session 8: Aspect Oriented Programming 354 Lesson Objectives 355 Overview 356 The Issue with Crosscutting Concerns 357 Copyright , LearningPatterns Inc. All rights reserved v

8 Crosscutting Illustrated 358 Aspect Oriented Programming (AOP) Defined 359 Spring AOP Introduction 360 Spring AOP With AspectJ Annotations 361 Defining an Aspect 362 Defining a Pointcut 363 Defining a Pointcut 364 Defining Advice 365 Configuring Spring 366 Triggering Advice 367 More on How Spring AOP Works 368 Lab 8.1 Hello AOP World 369 Pointcut Expressions and Advice 376 Pointcut Expressions 377 Sample execution Designator Patterns 378 Sample execution Designator Patterns 379 Other Designators Available in Spring AOP 380 Sample Designator Patterns 381 Combining Pointcut Expressions 382 Kinds of Advice 383 Advice Examples 384 Around Example 385 Around Example 386 Lab 8.2 More Spring AOP 387 XML Based AOP Support 392 Defining Aspects Using XML 393 AOP XML Configuration Example 394 Specifying Advice With XML 395 Lab 8.3 Using AOP XML Configuration [Optional] 396 Other Considerations 400 Spring Proxies and Direct Invocation 401 More on Spring Proxies 402 Issues with AOP 403 Issues with AOP 404 Is AOP Worth It? 405 Other AOP Capabilities and Functionality 406 Review Questions 407 Lesson Summary 408 Recap 410 Recap of what we've done 411 What Else is There 412 Resources 413 Copyright , LearningPatterns Inc. All rights reserved vi

9 Introduction Fast Track to Spring 3.x The Java Developer Education Series Copyright LearningPatterns Inc. All rights reserved. 1

10 Introduction Workshop Overview This is an in-depth course covering the use of the Spring 3 framework to build enterprise applications using Java The course, at a high level, covers the following areas of Spring technology Core features of Spring Data Access Features Transaction Support Spring Integration with Java Web Applications Spring Security Overview Aspect Oriented Programming (AOP) Copyright LearningPatterns Inc. All rights reserved. 2

11 Introduction Workshop Objectives To understand the Spring framework and use its capabilities, including: Spring Core: Dependency Injection (DI) and lifecycle management of application objects Using the Spring API and Spring configuration to write Spring programs Configuration covers both XML and annotations Data Access: Data access via Spring's data support DataSource support Hibernate and JPA-based DAOs Transactions: Control transactions declaratively with Spring Use the Spring annotations and XML configuration elements Web: Integrate Spring with Web applications Security: Understand the architecture and basic use of Spring Security AOP: Use Spring's AOP (Aspect Oriented Programming) capabilities to inject crosscutting concerns Copyright LearningPatterns Inc. All rights reserved. 3

12 Introduction Workshop Agenda Session 1: Introduction to Spring Session 2: More About Bean Properties Session 3: The Spring Container and API Session 4: Database Access With Spring Session 5: Transactions Session 6: Integrating Spring with Java Web Applications Session 7: [Optional] Spring Security Overview Session 8: [Optional] Aspect Oriented Programming (AOP) Copyright LearningPatterns Inc. All rights reserved. 4

13 Introduction Typographic Conventions Code in the text uses a fixed-width code font, e.g.: JavaTeacher teacher = new JavaTeacher() Code fragments use the same font, e.g. teacher.teach() We bold/color text for emphasis Filenames are in italics, e.g. JavaInstructor.java We sometimes denote more info in the notes with a star * Longer code examples appear in a separate code box - e.g. package com.javatunes.teach; public class JavaInstructor implements Teacher { public void teach() { System.out.println("BeanFactories are way cool"); } } * If we had additional information about a starred item in the slide, it would appear here in the notes We might also put other related information that generally pertains to the material in the slide Copyright LearningPatterns Inc. All rights reserved. 5

14 Introduction Labs Lab The workshop has numerous hands-on lab exercises, structured as a series of brief labs Many follow a common fictional case study called JavaTunes An online music store The labs are in the course book, and include detailed instructions Setup zip files are provided with skeleton code for the labs Students add code focused on the topic they're working with There is a solution zip with completed lab code Lab slides have an icon like in the upper right corner of this slide The end of a lab is marked with a stop like this one: STOP Copyright LearningPatterns Inc. All rights reserved. 6

15 Introduction Release Level Lab This manual has been tested with, and contains instructions for, running the labs using the following platforms: Spring 3.2 (tested with 3.2.2) The material is compatible with Spring 3.1 (see notes) Spring Security 3.1 (tested with 3.1.3) Java 6 or 7 Eclipse Java EE Edition (any fairly recent edition - tested with 4.2/Juno) Tomcat 7.0.x for the Spring/Web material Recent similar versions of the software will likely work except for potentially small configuration changes Any 3.2 version of Spring should work The APIs have not changed between 3.2 versions The course material is compatible with Spring 3.1 However, in order to make the labs easy to run in a lab environment, we supply all the external dependency jars required for the labs We supply the dependency jars for 3.2, and some of these may be different than the ones needed for 3.1 This is the main reason that you should stick with the versions we have tested with All labs have been tested on Microsoft Windows using the software listed above The labs should work on Unix with little modification, except for the database setup scripts, which need to be use Unix shell scripts Copyright LearningPatterns Inc. All rights reserved. 7

16 Session 1: Introduction to Spring Session 1: Introduction to Spring Overview Spring Introduction Dependency Injection Copyright LearningPatterns Inc. All rights reserved. 8

17 Session 1: Introduction to Spring Lesson Objectives Understand why we need the Spring Framework Understand what Spring is, and how it simplifies enterprise application development with Java Learn how Spring uses configuration information and Dependency Injection (DI) To manage the beans (objects) in an application To manage bean dependencies Copyright LearningPatterns Inc. All rights reserved. 9

18 Session 1: Introduction to Spring Overview Overview Spring Introduction Dependency Injection Copyright LearningPatterns Inc. All rights reserved. 10

19 Session 1: Introduction to Spring The Challenge of Enterprise Applications Enterprise applications have many complex requirements Many types, with complex dependencies Persistent data retrieved from / stored to a data store Transactional requirements Remote (distributed) access requirements Web access requirements Java / Java EE (Enterprise Edition) provides many capabilities to build enterprise applications Java SE: Basic building blocks like Java primitives and core libraries like Collections Java EE: Enterprise technologies like EJB, Servlets/JSP, JDBC However, there are shortcomings to the standard Java solution There really is no formal definition of an enterprise application Typically though, some of the characteristics they have are: Used in a business environment, often in business-critical domains Have some form of persistent storage Have some form of remote access (Web/HTTP, Web service, Distributed Objects, etc) Require some measure of scalability and fault tolerance The definition of enterprise application is not important Many Java applications share some of the requirements that we are outlining here Copyright LearningPatterns Inc. All rights reserved. 11

20 Session 1: Introduction to Spring Shortcomings of Java/Java EE Java/Java EE can have significant shortcomings, including: Little support for managing the lifecycle of your objects and the dependencies between them Managing large numbers of objects requires significant effort Java EE is large and requires a fairly heavyweight app server Even if using only a subset of capabilities (e.g. Web apps and transactions), the application server generally supports all of them Java EE has been difficult to use, and intrusive in its design Not as big an issue now Newer releases, such as EJB 3, are less intrusive Though rich in functionality, due to its complexity, and the complexity of the systems being written, Java / Java EE can have a number of shortcomings for writing these systems These programs are composed of many collaborating objects and technologies, which require significant effort to manage There are many design guidelines to help you with managing the collaboration of objects Best practices, design patterns, etc. These help you create a good design to make it easier to write and maintain your program However, these still require that you write the code that manages the collaboration of objects The newer Java and Java EE technologies have started to address the ease of use issue The use of Java annotations (introduced in Java 5), new versions of existing technologies (such as EJB 3), and completely new technologies such as JavaServer Faces (JSF) have made it significantly easier to use Java Copyright LearningPatterns Inc. All rights reserved. 12

21 Session 1: Introduction to Spring What is Spring? Lightweight framework to build enterprise applications "Lightweight" meaning non-intrusive in your programming, and allowing you to use only what you need It includes the following capabilities A Dependency Injection (Inversion of Control) container to manage objects and their dependencies A DAO package that abstracts JDBC and simplifies its use An ORM package providing integration with technologies such as Hibernate and JPA (Java Persistence API) An AOP package for doing aspect-oriented programming A Web package to integrate with Web technologies An MVC package that provides a full Model-View-Controller based Web framework for Web applications A security framework for authentication and authorization DAO stands for Data Access Object ORM stands for Object-Relational Mapping Copyright LearningPatterns Inc. All rights reserved. 13

22 Session 1: Introduction to Spring The Spring Modules Module diagram from the Spring Reference Documentation Copyright LearningPatterns Inc. All rights reserved. 14

23 Session 1: Introduction to Spring The Spring Distribution Spring home page: Can download Spring from this site Framework distributed as a set of jar files Each module packaged in its own archive e.g. spring-beans release.jar The core Spring download has the all the spring module jars, a reference manual, and API docs Spring has many dependencies on external technologies e.g. - Apache commons logging, jars for AOP, and more Not included in the core Spring download Maven is commonly used to manage Spring's dependencies Project management tool - can automatically download needed dependencies Maven covered more later You can download the distribution from In the past, the dependencies were available as a separate download from the Spring download pages These are no longer provided Copyright LearningPatterns Inc. All rights reserved. 15

24 Session 1: Introduction to Spring The Spring Distribution Below left, is the folder structure of the core distribution Below right, are some of the jars in the libs folder Note that there are source and javadoc jars also At bottom is the docs folder Copyright LearningPatterns Inc. All rights reserved. 16

25 Lab 1.1: Setting Up the Environment Lab 1.1 Setting Up the Environment Copyright LearningPatterns Inc. All rights reserved. 17

26 Lab 1.1: Setting Up the Environment Lab 1.1 Set up the Environment Lab Overview: In this lab, we will become familiar with the lab structure, set up our working environment, and test it to make sure it is running well The end goal is to compile and run an application that requires the Spring libraries Objectives: Become familiar with the lab structure Set up our environment Write and run a simple application that requires Spring Builds on previous labs: None Approximate Time: minutes Copyright LearningPatterns Inc. All rights reserved. 18

27 Lab 1.1: Setting Up the Environment Information Content and Task Content Lab Within a lab, information only content is presented in the normal way the same as in the student manual pages Like these bullets at the top of the page Tasks that the student needs to perform are in a box with a slightly different look to help you identify them An example appears below Tasks to Perform Look at these instructions, and notice the different look of the box as compared to that above Make a note of how it looks, as future labs will use this format OK Now get out your setup files; we're ready to start working Copyright LearningPatterns Inc. All rights reserved. 19

28 Lab 1.1: Setting Up the Environment Setup Environment Lab Make sure Java is installed Tasks to Perform Usually in a folder (for Java 7) like C:\Program Files\Java\jdk1.7.0_nn If not, then install it - it can be downloaded from: Check that Spring 3.2 is installed likely in a folder like: C:\spring-framework RELEASE It is not required - you can use it for reviewing the documentation We supply the needed jars in the setup It can be downloaded from Copyright LearningPatterns Inc. All rights reserved. 20

29 Lab 1.1: Setting Up the Environment Extract the Lab Setup Zip File Lab To set up the labs, you'll need the course setup zip file * e.g.: LabSetup_Spring3x_Tomcat-Eclipse_.zip Our base working directory for this course will be C:\StudentWork\Spring This directory will be created when we extract the Setup zip It includes a directory structure and files (e.g., Java files, XML files, other files) that will be needed in the labs All instructions assume that this zip file is extracted to C:\. If you choose a different directory, please adjust accordingly Tasks to Perform Unzip the lab setup file to C:\ This will create the directory structure, described in the next slide, containing files that you will need for doing the labs Depending on how your training environment, the setup files may be given to you in different ways, including: Present on the training machines as a zip file Already unzipped on the training machine Given to you by the instructor Available as a network share or web download Your instructor will let you know how to access them Copyright LearningPatterns Inc. All rights reserved. 21

30 Lab 1.1: Setting Up the Environment Lab Directory Structure Lab StudentWork\Spring contains Derby: Database files SpringDependencies: jars for Spring dependencies SpringLibraries: Spring jars workspace: Eclipse workspace StudentWork\Spring\workspace will contain the following folders: common: shared files (if any) LabNN : Folder for Lab NN LabNN/src : Java source LabNN/bin/ : compiled code (Eclipse's standard location) To make it easier to open command windows in the lab dirs, we've included a utility in the setup that allows you to right click on a folder to open a command prompt Not needed for Windows 7, where you can press and hold the shift key, then right click on a folder and select "Open Command Window Here" For earlier Windows versions, install this as follows: Go to the Resources/CommandPromptHere folder Right click on the.reg file there, and select Merge Once you've done that, right clicking on a folder will show a Command Prompt Here selection in the context menu - Select that to open a command prompt in the directory Copyright LearningPatterns Inc. All rights reserved. 22

31 Lab 1.1: Setting Up the Environment General Instructions Lab Root lab folder for this lab is: C:\StudentWork\Spring\workspace\Lab01.1 Already exists in your workspace You'll create a new Eclipse project in this folder, which contains starter files that we provide In general, all the lab files are under this project/folder and instructions are given relative to this project/folder Detailed instructions are included in this lab Including complete Eclipse instructions, as well as details about the lab requirements Subsequent labs are similar to this lab, so include fewer detailed instructions Copyright LearningPatterns Inc. All rights reserved. 23

32 Lab 1.1: Setting Up the Environment The Eclipse Development Environment Lab Eclipse: Open source platform for building integrated development environments (IDEs) Used mainly for Java development Can be flexibly extended via plugins to add capabilities is the main website This lab includes detailed instructions on using Eclipse Starting it, creating and configuring projects, etc. Other labs include fewer Eclipse details - they may just say build/run as previously Just use the same procedures to build/run as in this lab Refer back to these lab instructions as needed The Eclipse source base was originally developed by IBM It was released by IBM into open source IBM's RAD (and previously its WSAD) environment is built on top of Eclipse Copyright LearningPatterns Inc. All rights reserved. 24

33 Lab 1.1: Setting Up the Environment Launch Eclipse Lab Tasks to Perform Launch eclipse: Go to c:\eclipse and run eclipse.exe A dialog box appears prompting for workbench location (below left) Set the workbench location to C:\StudentWork\Spring\workspace If a different default Workbench location is set, change it Click OK Close the Welcome screen: Click the X on its tab (below right) If Eclipse was installed elsewhere, adjust the paths to the Eclipse executable accordingly You can put a shortcut to this executable on your desktop You can also have your lab workspace in a different location Again, just adjust the lab instructions as required Copyright LearningPatterns Inc. All rights reserved. 25

34 Lab 1.1: Setting Up the Environment Workbench and Java Perspective Lab Tasks to Perform You should be in a Java EE perspective * Open a Java Perspective: Click the Perspective icon at the top right of the Workbench, and select Java (see below left) Close the Java EE perspective by right clicking its icon, and selecting close (see below right) Unclutter the Java Perspective by closing some views Close the Task List, Outline and Hierarchy views (click on the X) Open the Navigator View (Window Show View Navigator) The Eclipse Java EE version opens in the Java EE perspective by default Other versions may open in a different perspective If you're already in a Java perspective, you don't need to switch perspectives, and there is nothing for you to do Note that you'll need the Eclipse Java EE version for the Web and Security labs To save a our "uncluttered" perspective as the default Java perspective go to Window Save Perspective As Java You can reset the perspective to its defaults via Window Reset Perspective Copyright LearningPatterns Inc. All rights reserved. 26

35 Lab 1.1: Setting Up the Environment The Java Perspective Lab Copyright LearningPatterns Inc. All rights reserved. 27

36 Lab 1.1: Setting Up the Environment Create User Libraries Lab We'll need to include a number of Spring jars in our classpath We include the Spring jars from the Spring distribution in the setup We also supply other external dependencies in a separate folder We'll set these up as a user library for ease of use Tasks to Perform Go to Window Preferences Java Build Path User Libraries financial info Click New, in the next dialog, call the library Spring, and press OK Click the Add External JARs button, browse to StudentWork\Spring\SpringLibraries, select all the jars in that folder, and click OK (see notes) Select the Spring library again, click Add External JARs, browse to StudentWork\Spring\SpringDependencies, add in all jars in that folder Creates a library with the Spring distribution and dependency jars We'll use it to configure the project build path We include all the Spring jars from the Spring distribution in our setup This is for ease of use - the Spring distribution includes a lot of extraneous jars (src and javadoc) mixed in with the standard jars This can be confusing when starting out, so we just supply them separately We supply all needed dependencies in the SpringDependencies folder These were figured out by using Maven and seeing what dependencies were added to the project In this folder, we supply all the external dependencies for all the labs This is quite a bit more than is needed for this lab Copyright LearningPatterns Inc. All rights reserved. 28

37 Lab 1.1: Setting Up the Environment Create a Project for our Application Lab Tasks to Perform Create a Java Project * Call the project Lab01.1 Eclipse will then automatically set the project folder to Lab01.1 This folder already exists in the workspace It contains a Java project laid out for Eclipse Click Next This will bring you to a dialog where you can set the Java Settings for the project To create a new Java Project, use the menu item File New Java Project There are many other ways to create a project You can use the new icon on the left hand side of the toolbar, as shown above You will need to create a new Java project in Eclipse each time the lab instructions tell you to use a new Lab directory This happens several times in the course, and you'll need to create a new project each time Copyright LearningPatterns Inc. All rights reserved. 29

38 Lab 1.1: Setting Up the Environment Add the Spring Library to the ClassPath Lab Tasks to Perform In the Java Settings dialog, click the Libraries tab * Click the Add Library button, and in the dialog that comes up, select User Library then click Next Check off Spring, then click Finish in all open dialogs * If you forget to add the library in this step, you can always add it later as follows Right click on the project, select Properties, then select Java Build Path Go to the Libraries tab, and add in the Spring library as described above When the project is created, Eclipse will attempt to compile all the Java source This will lead to warnings about unused imports, variables, etc. You can just ignore these most of them are because the files we give you are just skeletons, and not complete. If you want, you can shut these warnings off as follows: Window Preferences Java Compiler Errors/Warnings Go to the "Unnecessary Code" section, and change the settings for "Unused import", "Unused local or private member", and "Local variable is never read" to "Ignore" Copyright LearningPatterns Inc. All rights reserved. 30

39 Lab 1.1: Setting Up the Environment Running the Lab Lab Tasks to Perform We will use Eclipse to run a skeleton program we supply in TeachMeSpring.java After a clean build (one that is error-free, but not necessarily warning-free), do the following In the Package Explorer pane, right click on TeachMeSpring.java (in package com.javatunes.teach under the src folder) Select: Run As -> Java Application This will automatically find the main method in TeachMeSpring and run it for you Copyright LearningPatterns Inc. All rights reserved. 31

40 Lab 1.1: Setting Up the Environment Program Output Lab You should see output in the Eclipse Console view showing the results of running the program Similar to that shown below If you see any exceptions, then you have a problem somewhere Note: You will follow similar procedures whenever you have a Java program to run in the labs The only thing that may change is the program class that you'll need to right click on to run STOP Copyright LearningPatterns Inc. All rights reserved. 32

41 Session 1: Introduction to Spring Spring Introduction Overview Spring Introduction Dependency Injection Copyright LearningPatterns Inc. All rights reserved. 33

42 Session 1: Introduction to Spring Managing Beans Managing application objects is a core Spring capability These managed objects are called beans Just a POJO (Plain Old Java Object) Bean is a common name (e.g. JavaBeans and EJB) The Spring container manages objects Often called the Dependency Injection (DI) or Inversion of Control (IoC) container Configuration metadata is used by the container to instantiate, configure, and assemble your beans Generally supplied in simple XML format You write a configuration with bean definitions and dependencies The container does the work of managing the beans Spring will create and initialize bean instances based on your configuration data You can then request those instances from the Spring container by name We'll see how this works soon We'll cover the Spring container, and the principles behind it, in more detail later For now, we will just describe some of its basic capabilities Spring 2.x added a number of Java 5 annotations that can be used, and Spring 3 added the ability to write the configuration using Java We'll cover these later Configuration metadata can also be provided in the Java properties format, or even provided programmatically (using Spring's public API) These are generally more cumbersome to use, and we won't cover them in this course The vast majority of Spring users use the XML format In fact, the Spring IoC container is totally decoupled from the external form of the metadata It has its own internal format which it uses to store this information Copyright LearningPatterns Inc. All rights reserved. 34

43 Session 1: Introduction to Spring A Basic Spring Application Copyright LearningPatterns Inc. All rights reserved. 35

44 Session 1: Introduction to Spring Some Bean Classes Assume the following types (your business objects) Teacher interface defining our functionality JavaInstructor: Concrete class, implementing Teacher Note: Spring strongly advocates programming to interfaces (see notes) Let's look at how to manage instances of our types with Spring package com.javatunes.teach; public interface Teacher { public void teach(); } package com.javatunes.teach; public class JavaInstructor implements Teacher { public void teach() { System.out.println("BeanFactories are way cool"); } } Programming to interfaces provides many advantages by decoupling your code from concrete implementation classes This is not a concept unique to Spring Many design patterns are based on the decoupling gained by programming to an interface We'll soon see how the Spring framework makes these advantages even more usable and powerful by helping manage the dependencies that have been abstracted using interfaces Copyright LearningPatterns Inc. All rights reserved. 36

45 Session 1: Introduction to Spring Configuration Metadata A Spring configuration contains bean definitions And information about your beans (the metadata) Bean definitions correspond to actual objects in your app that the Spring container will manage Typically - many bean definitions and dependencies Beans are configured with a top level <beans> element It contains namespace declarations and <bean> elements as shown in the applicationcontext.xml file below <?xml version="1.0" encoding="utf-8"?> <!-- The beans namespace is the default one for the document --> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" <bean id="springguru" class="com.javatunes.teach.javainstructor"/> </beans> applicationcontext.xml is a fairly standard name for the Spring config file, but you can name it anything that you want Spring 2.0 and later provided an XML Schema for the XML configuration file The examples and lab setup files have the necessary XML namespace information in them to refer to the Spring XML Schema properly This is standard XML usage, and we don't go into the details here of how to use an XML Schema Refer to an XML reference if you need more detail on this The XML Schema is the recommended way to use Spring, and we'll use it in this course Typically you'll configure beans such as Service layer objects, DAO objects, Hibernate session factories, JMS queue references Some BeanFactory implementations also permit the registration of existing objects that have been created outside the factory (by user code) The schemalocation property shown in the slide is for Spring for earlier versions of Spring, you would use the appropriate spring-beans-n.n.xsd e.g. For Spring 3.0, use spring-beans-3.0.xsd - there is very little difference between them Copyright LearningPatterns Inc. All rights reserved. 37

46 Session 1: Introduction to Spring Declaring Beans Each bean definition must specify a package-qualified class name Usually the bean implementation class (i.e. the class that the container will instantiate) In our example, the class attribute, specifies the implementation as com.javatunes.teach.javainstructor In general, a bean identifier (or name) is also specified In our example, the id attribute, specifies the identifier as springguru It is a label for the bean both in code and the config file A bean can have multiple names (or aliases) Generally, bean names use camelcase for bean names (e.g. springguru) There are more sophisticated ways to create beans, for example with a factory class, in which case the class name may not be the actual implementation class If you don't specify a bean name, the container will generate a unique name for the bean This can be useful in some more sophisticated scenarios The springguru name follows the same convention as Java instance field names Bean names start with a lowercase letter, and are camel cased from then on Bean names must be unique within the container the bean is hosted in Usually a bean will have a single name If it has multiple names, these are considered aliases The id attribute must follow the standard XML rules for ids There is a limited set of characters that are allowed for XML ids The name attribute can also be used to specify (multiple) names You can have a value that specifies multiple bean ids separated by a comma, semicolon, or whitespace If there is no id attribute, the first name becomes the identifier, the rest are aliases You may use the id and name attributes at the same time Copyright LearningPatterns Inc. All rights reserved. 38

47 Session 1: Introduction to Spring The Spring Container Spring container instantiates/configures application objects Provides a configuration mechanism for managing objects And resolves object dependencies based on configuration org.springframework.context.applicationcontext Core API to access the Spring container in your code Multiple implementations provided for flexibility, e.g. ClassPathXmlApplicationContext: Commonly used implementation that loads resources from the class path ApplicationContext extends interface org.springframework.beans.factory.beanfactory Defines many core methods, but usually not used directly ApplicationContext is the recommended API choice Copyright LearningPatterns Inc. All rights reserved. 39

48 Session 1: Introduction to Spring Working With Spring High level scenario for using Spring includes the following: Create Spring configuration data for your beans e.g. In an XML file like applicationcontext.xml Or via annotations in code (covered later) The "cookbook" telling Spring how to create objects Initialize Spring container, create access point, e.g. Create an application context instance that reads config data It will initialize the beans in the config file Use the context instance to access beans Retrieve beans via the context and use them e.g. use getbean() to look up a bean by name getbean() is part of BeanFactory/ApplicationContext API There are many, many usage scenarios for Spring And many, many different alternatives for each scenario Spring is very large, and has a lot of flexibility and capability In this initial introduction we show you one straightforward way of using Spring We will gradually introduce more capabilities throughout the course Copyright LearningPatterns Inc. All rights reserved. 40

49 Session 1: Introduction to Spring A Simple Spring Example The code below provides a simple Spring example Based on applicationcontext.xml seen earlier Instantiates a ClassPathXmlApplicationContext to read applicationcontext.xml from the classpath to create the spring container Looks up the springguru bean from the container and uses it Closes the context (destroying all beans) * package com.javatunes.teach; import org.springframework.context.support.classpathxmlapplicationcontext; public class TeachMeSpring { public static void main(string[] args) { ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); // Note that getbean uses Java generics (no casting needed) Teacher teacher = ctx.getbean("springguru", Teacher.class); teacher.teach(); // Use our bean ctx.close(); // Close the context } } ClassPathXmlApplicationContext(String) loads the named file from the classpath Uses Spring-based resource classes (org.springframework.core.io.resource implementations) to access the file The resource classes abstract access to resources - often used by other classes to access data ClassPathResource is a concrete implementation that allows you to easily access resources on the classpath, e.g. Resource resource = new ClassPathResource("applicationContext.xml"); This is how ClassPathXmlApplicationContext accesses its resources The context implementations uses Spring resources to locate the configuration files The Resource interface allows you to flexibly specify paths to resources as resource strings These are then mapped by a particular implementation to the actual resource, for example a file on a file system or from the Java classpath A bean definition can be seen as a recipe for creating one or more actual objects The container looks at the recipe for a named bean when asked, and uses the configuration metadata encapsulated by that bean definition to create (or acquire) an actual object Copyright LearningPatterns Inc. All rights reserved. 41

50 Session 1: Introduction to Spring Why Bother? The example looks like a lot of work to create a single object! Main benefit: We've decoupled our code from a dependency on the implementation class JavaInstructor Our code does not need to know about JavaInstructor We just know about the functionality we need i.e. The Teacher interface (which JavaInstructor implements) We can use any conforming implementation in our configuration Our client code will not change This can be very useful for complex systems We'll soon see additional capabilities that make Spring useful In this simple example, it looks like we've done quite a bit of work to instantiate a single instance of a single class What is the benefit? The decoupling we've achieved seems like a simple thing, but it has a lot of benefits, especially when maintaining large systems We'll see how useful it can be when we explore more of the capabilities Copyright LearningPatterns Inc. All rights reserved. 42

51 Session 1: Introduction to Spring Some BeanFactory/ApplicationContext API boolean containsbean(string): returns true if BeanFactory contains a bean definition or instance with the given name <T> T getbean(string, Class<T> requiredtype): Returns a bean instance, registered under the given name Spring 3 style using Java generics (see notes) and is preferred Object getbean(string): Old style non generics version Requires cast Class<?> gettype(string name): Returns the Class of the bean with the given name boolean issingleton(string): Determines whether or not the named bean is a singleton String[] getaliases(string): Return the aliases for the given bean name, if any Many more methods - view the javadoc for more details The methods shown are a part of the BeanFactory API - inherited by ApplicationContext getbean(string, Class) returns either a singleton (shared) instance, or newly created bean NoSuchBeanDefinitionException thrown if the bean can't be found BeansException thrown if an exception occurred while instantiating/preparing the bean BeanNotOfRequiredTypeException thrown if the bean is not of the required type Object getbean(string) returns an object which is then cast to the required type The newer getbean(string,class) method is generally preferred. gettype(string) throws NoSuchBeanDefinitionException if the bean can't be found issingleton(string) throws NoSuchBeanDefinitionException if bean can't be found The method <T> T getbean(string, Class<T> requiredtype) may look strange The first <T> in the return type simply indicates that this is a generic method, parameterized by the type parameter <T> The T return value indicates that the return type is generic (that is, it will take on different types based on the <T> parameter) The Class<T> argument indicates that when you call the method, you pass in the class which specifies what type <T> actually is in that call Copyright LearningPatterns Inc. All rights reserved. 43

52 Lab 1.2: Hello Spring World Lab 1.2 Hello Spring World Copyright LearningPatterns Inc. All rights reserved. 44

53 Lab 1.2: Hello Spring World Lab 1.2 Hello Spring World Lab Overview: In this lab, we will create and use a Spring context to access a bean instance The end goal is to build a complete (and simple) Spring application and run it This lab uses the JavaInstructor, Teacher, and TeachMeSpring types shown previously in the student manual Objectives: Become familiar with the different parts of a basic Spring program Write and run a simple Spring application Builds on previous labs: 1.1 Approximate Time: minutes The purpose of this lab is to become familiar with the different parts of a Spring application Accordingly, the program is as simple as we can make it It mirrors the code already shown in the previous section In later labs, we'll work with more complex applications Copyright LearningPatterns Inc. All rights reserved. 45

54 Lab 1.2: Hello Spring World Writing and Configuring a Bean in Spring Lab Tasks to Perform Continue to work in the Lab01.1 project Open up the JavaInstructor.java file The class is in the com.javatunes.teach package, under src Make sure JavaInstructor implements the Teacher interface Remember that we code to interfaces to decouple us from a specific implementation Open up the src/applicationcontext.xml file Click the Source tab to edit it Finish up the declaration of the <bean> element by declaring: An id of springguru A class of com.javatunes.teach.javainstructor There are two other files in the src tree that we will use in the next lab InfoSource.java and SpringCourseBook.java Ignore these for now Copyright LearningPatterns Inc. All rights reserved. 46

55 Lab 1.2: Hello Spring World Using a Bean in a Program Lab Tasks to Perform Open up TeachMeSpring.java, look for the TODO comments, and add in the following code First, create a ClassPathXmlApplicationContext to read applicationcontext.xml Next, look up the springguru bean from the context Call teach() on the springguru bean Finally, call close() on the context Make sure you have no compilation errors in your code Run the TeachMeSpring program again Run the same way as in previous labs You should see the output from the teach() method You've successfully configured and used a bean with Spring Congratulations! Copyright LearningPatterns Inc. All rights reserved. 47

56 Lab 1.2: Hello Spring World Logging and Additional Things (Optional) We've provided a log4j.properties file in src This configures some of the logging that Spring will do You can reduce the logging output by opening this file, and changing the INFO to WARN at the top line of the file: log4j.rootlogger=warn, stdout You can increase the logging by using DEBUG instead Other things to try Try looking up the bean by a different name what happens? Try casting the bean you look up to a JavaInstructor instead of a Teacher Does this work? Is it a good idea? (see notes) Change your code back to your original solution before going on STOP Spring has logging built into it It uses commons-logging by default, which will detect the log4j jar file and use that if it is on the classpath You can see the logging by properly configuring it, as we do in the log4j.properties file The details of log4j are beyond the scope of this course Casting the bean you look up to a JavaInstructor will work These are POJOs, and the actual type is JavaInstructor It's not a good idea though, because you are defeating the purpose of decoupling your code from the actual implementation type Copyright LearningPatterns Inc. All rights reserved. 48

57 Session 1: Introduction to Spring Dependencies and Dependency Injection Overview Spring Introduction Dependency Injection Copyright LearningPatterns Inc. All rights reserved. 49

58 Session 1: Introduction to Spring Dependencies Between Objects Different objects work together in an OO application e.g., Object A directly uses Object B to accomplish a goal Object A depends on Object B Direct dependencies can lead to unwanted traits Rigidity: Hard to make changes - they affect many other parts of the system Fragility: Changes cause unexpected failures in other system areas Immobility: Hard to reuse functionality elsewhere - modules can't be disentangled We'll show a direct dependency example, then show an alternative approach using Dependency Inversion In straightforward applications, Object A will often just create an instance of Object B and use it Object A is highly coupled to, and directly dependent on, Object B Copyright LearningPatterns Inc. All rights reserved. 50

59 Session 1: Introduction to Spring Example of a Direct Dependency Assume JavaInstructor uses SpringCourseBook Below, JavaInstructor creates a SpringCourseBook instance directly JavaInstructor depends on the lower level module details If the data source changes - e.g. to a SpringWiki, then JavaInstructor code must change (see notes) public class SpringCourseBook { // package statements not shown * public String getdata() { return "Dependencies are not so cool"; } } public class JavaInstructor implements Teacher { SpringCourseBook springbook = new SpringCourseBook(); public void teach() { System.out.println(springBook.getData()); } } Assume that all the classes in the examples in this session are in the com.javatunes.teach package We'll be leaving out all the package statements in the Java code examples for brevity Assume we want to get our information from a class called SpringWiki Not shown, but assume it has a getdata() method In that case, JavaInstructor might need to be changed to something like that below public class JavaInstructor implements Teacher { SpringWiki springwiki = new SpringWiki(); public void teach() { System.out.println(springWiki.getData()); } } This is not such a big deal if you have to change it in one place But imagine if you had to change it in 100 places, or 10,000 places Copyright LearningPatterns Inc. All rights reserved. 51

60 Session 1: Introduction to Spring Dependency Inversion Principal High level or low level modules should should depend upon abstractions and not upon each other Use abstractions, e.g. interfaces, that all modules depend on High level modules are written in terms of abstractions (the interfaces), and not directly in terms of low level modules Dependencies exist, but not exposed in implementation classes Using this design strategy has a number of advantages: Facilitates less coupled components With a high degree of separation of responsibilities Produces greater flexibility Implementations can be swapped without affecting other modules Facilitates reuse of components They're less coupled to other parts of an application Dependency Inversion is not a new idea The idea of "Programming to Interfaces" has been around since long before Java It has been used in non-oo languages also, for example the stdio module in the C programming language abstracted away the details of the actual devices doing the output Many people don't use this design in building applications Even though we know of good design principals, there is no way to make sure people use them We'll soon look at Spring's Dependency Injection which makes this design strategy even easier to use We talk of modules here, which in Java are basically reflected as dependencies between different classes Copyright LearningPatterns Inc. All rights reserved. 52

61 Session 1: Introduction to Spring Example of Dependency Inversion Both JavaInstructor and SpringCourseBook depend on InfoSource (an interface) neither depend on the other public interface InfoSource { public String getdata(); } public class SpringCourseBook implements InfoSource { public String getdata() { return "Dependencies are not so cool"; } } public class JavaInstructor implements Teacher { private InfoSource info; public void setinfo (InfoSource infoin) { info=infoin; } public void teach() { System.out.println(info.getData()); } } In the code example, we can see that JavaInstructor knows nothing about SpringCourseBook Instead, it depends on the InfoSource interface (the abstraction) When JavaInstructor is created, it is initialized with an instance of some InfoSource implementation However, it doesn't know any details of this implementation, and doesn't even know its exact type SpringCourseBook likewise depends on the abstraction (it implements the InfoSource interface) The abstraction (the interface) is the common language that lets the different part of the system work together with depending directly on each other Copyright LearningPatterns Inc. All rights reserved. 53

62 Session 1: Introduction to Spring Example of Dependency Inversion Below, JavaInstructor is initialized with a SpringCourseBook instance (that implements InfoSource) JavaInstructor only sees this as the InfoSource type We could initialize JavaInstructor with any type that implemented InfoSource e.g. a SpringWiki We've decoupled the modules, and made them more flexible and easier to use, reuse, and maintain public class TeachMeSpring { } public static void main(string[] args) { SpringCourseBook springbook = new SpringCourseBook(); JavaInstructor myinstructor = new JavaInstructor(); myinstructor.setinfo(springbook); myinstructor.teach(); } In the example above, we are still creating SpringCourseBook in a fairly straightforward way This exposes the actual implementation class of the lower level module (SpringCourseBook) in our TeachMeSpring code There are other, more sophisticated, ways to create these lower level modules For example, we could use factories of some sort to more completely abstract which InfoSource is being used We will soon show how Spring can do this for you Whenever you have modules depending on one another, something has to know about the implementation details Even if it's abstracted through multiple layers, there is still a layer somewhere which creates the instance of the actual implementation The goal is to do this in a way that makes your code easier to write, reuse, and maintain We'll see how Spring deals with this soon Copyright LearningPatterns Inc. All rights reserved. 54

63 Session 1: Introduction to Spring Dependency Injection (DI) in Spring With Dependency Injection, Spring lets you abstract dependencies even more The Spring container can initialize and inject dependencies into a bean Via constructors, properties in the bean, or arguments to a factory method Dependencies are defined in the Spring configuration The Spring container uses these dependency definitions to initialize the bean No need to explicitly initialize dependencies in your code Your bean classes are normal POJO classes You only need appropriate setter methods or constructors needed to initialize the dependencies There is nothing else special about the bean classes Dependency injection is a fancy way of saying that the container will initialize all the dependencies in the bean when the bean is created The bean has to be a bean whose lifecycle is managed by the container Copyright LearningPatterns Inc. All rights reserved. 55

64 Session 1: Introduction to Spring Dependency Injection Configuration The Spring configuration below uses DI Declares two beans: springbook and springguru <property name="info" ref="springbook"/> tells the container to initialize the info property of springguru Using the instance of SpringCourseBook defined above it Uses setter injection - calling setinfo() on springguru You don't need to write any code for the injection to happen <?xml version="1.0" encoding="utf-8"?> <beans > <!-- Namespace declarations omitted --> <bean id="springbook" class="com.javatunes.teach.springcoursebook"/> <bean id="springguru" class="com.javatunes.teach.javainstructor"> <property name="info" ref="springbook"/> </bean> </beans> The container first creates an instance of SpringCourseBook, with the id springbook The container next creates an instance of JavaInstructor using the no-arg constructor To accomplish the DI, the container calls the setinfo method, passing in the instance of SpringCourseBook that it had created The result is a fully initialized JavaInstructor instance The <property> element tells the container to use setter injection to initialize the dependency Setter injection uses the standard setter methods on your bean It follows the standard property naming conventions, so if the property is named info, it will call the setinfo method to initialize the dependency There are other ways of initializing the dependency, such as constructor injection, that we'll see later The bean reference can also be declared using a nested <ref> element as shown below <property name="info"><ref bean="springbook"/></property> Generally, the ref attribute shown in the slide is easier to use and understand You can use the nested element if for some reason it is clearer to express it this way than as an attribute (this is also provided for backwards compatibility with earlier Spring releases) Copyright LearningPatterns Inc. All rights reserved. 56

65 Session 1: Introduction to Spring Dependency Injection Example The example below shows how to use our beans with Spring Our main code is decoupled from JavaInstructor -it is written in terms of the Teacher interface JavaInstructor, is totally decoupled from the concrete class SpringCourseBook, it's written in terms of InfoSource The JavaInstructor instance's info property is injected with a SpringCourseBook instance by the Spring container This is transparent to all your code // imports not shown public class TeachMeSpring { } public static void main(string[] args) { ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); Teacher teacher = ctx.getbean("springguru", Teacher.class); teacher.teach(); } Note that your SpringCourseBook and JavaInstructor class definitions didn't need to change to use DI Of course, they had to support the design principle of Dependency Inversion, which we had already done Once this was done, we didn't need any changes or additional code to support DI Note also that there is nothing in your TeachMeSpring code which shows that JavaInstructor depends on SpringCourseBook This is defined in your configuration, and handled for you by the container Note that the no-arg constructor is present by default in JavaInstructor since we haven't defined any constructors at all If we defined constructors, and still wanted to use only setter injection, as for the configuration file in this example, we would have to include a no-arg constructor We'll take a look at constructor injection, which allows us to use constructor arguments, a little later Copyright LearningPatterns Inc. All rights reserved. 57

66 Session 1: Introduction to Spring Advantages of Dependency Injection DI reduces coupling between modules in your code Coupling is basically a measure of the dependencies We've seen this reduction in two ways in our example: JavaInstructor is not coupled to SpringCourseBook TeachMeSpring is not coupled to JavaInstructor or SpringCourseBook The dependencies are still there but not in the code Dependencies are moved to the spring configuration They're injected into beans without your needing to write code Commonly referred to as wiring beans together This leads to more flexible code that is easier to maintain At a cost using Spring, and maintaining the spring configuration Coupling is the measure of how much a module of code relies on other modules Loosely coupled code is generally considered better code Consider some of the following scenarios, and how DI makes them easier Testing your code with testing framework such as JUnit can be much easier with DI you can configure the application to use mock objects wherever you want without changing your code at all Testing different versions of classes can be done just by changing the configuration metadata In fact, any implementation class that implements the particular interfaces being used can be swapped into your program simply by changing the configuration information There is debate about how worthwhile DI and frameworks like Spring are However, the principles that it is based on that lead to loose coupling are widely accepted Spring simply makes it easier to apply these principles The effort required to adopt and use Spring is not trivial, but for larger projects the initial cost of adopting Spring can be well worth it Copyright LearningPatterns Inc. All rights reserved. 58

67 Session 1: Introduction to Spring Dependency Injection Reduces Coupling The simplest case, JavaInstructor coupled to SpringCourseBook JavaInstructor SpringCourseBook JavaInstructor coupled to InfoSource only TeachMeSpring coupled to JavaInstructor and SpringCourseBook JavaInstructor creates TeachMeSpring creates <<interface>> InfoSource implements SpringCourseBook Using DI - TeachMeSpring only coupled to Teacher JavaInstructor only coupled to InfoSource <<interface>> Teacher looks up implements injects JavaInstructor <<interface>> InfoSource TeachMeSpring ApplicationContext In the slide, we show diagrams of the three different ways we structured our code in the earlier slides In the DI version, the couplings are ONLY to interfaces This is much better than being coupled to actual implementation classes It increases flexibility, testability, and ease of maintenance Copyright LearningPatterns Inc. All rights reserved. 59

68 Lab 1.3: Dependency Injection Lab 1.3 Dependency Injection Copyright LearningPatterns Inc. All rights reserved. 60

69 Lab 1.3: Dependency Injection Lab 1.3 Dependency Injection Lab Overview: In this lab, we'll work with Spring's DI capabilities We will add a property (a dependency on another bean) to the JavaInstructor class, and initialize it using Spring DI The main program will not change at all Again, the program is kept very simple so the concepts will be clear Objectives: Become familiar with Spring DI, and use it in a program Builds on previous labs: 1.2 Approximate Time: minutes Copyright LearningPatterns Inc. All rights reserved. 61

70 Lab 1.3: Dependency Injection Writing and Configuring a Bean in Spring Lab Tasks to Perform Continue to work in the Lab01.1 project Open up SpringCourseBook for editing Make sure that SpringCourseBook implements the InfoSource interface Open up JavaInstructor for editing Add in a property called info, of type InfoSource You'll need an instance field of type InfoSource, as well as a getter/setter method for this field Modify the teach() method to print out the data from the info properties getdata() method We won't initialize the info property that will be done with DI All the classes we're working with are in the com.javatunes.teach package Copyright LearningPatterns Inc. All rights reserved. 62

71 Lab 1.3: Dependency Injection Using a Bean in a Program Lab Tasks to Perform Open up the src/applicationcontext.xml file Add in a new bean element for SpringCourseBook Give it an id of springbook Modify the <bean> element for springguru by initializing its info property with a <property> element Use the springbook bean to initialize the info property Run the program as before The output should now be whatever data the SpringCourseBook returns The main program doesn't change at all the JavaInstructor dependency on SpringCourseBook is completely hidden JavaInstructor is also decoupled from SpringCourseBook Copyright LearningPatterns Inc. All rights reserved. 63

72 Lab 1.3: Dependency Injection Additional Things to Try (Optional) Lab In applicationcontext.xml, try leaving out the initialization of the springguru bean's info property Run your program What happens? Why? Change your code back to your original solution before going on STOP Copyright LearningPatterns Inc. All rights reserved. 64

73 Session 1: Introduction to Spring Review Questions What is Spring? How does Spring help you to build enterprise applications? What is Dependency Injection, and how does it work in Spring Copyright LearningPatterns Inc. All rights reserved. 65

74 Session 1: Introduction to Spring Lesson Summary Spring is a lightweight framework for building enterprise applications whose capabilities include: Dependency Injection Persistence support (DAO and ORM) AOP capabilities Integration with standard Web technologies An MVC based Web package Spring helps build complex enterprise applications Provides a non-intrusive, lightweight solution for managing complex dependencies between Java objects Supplies many of the important capabilities of Java EE in a less complex and lighter weight manner Copyright LearningPatterns Inc. All rights reserved. 66

75 Session 1: Introduction to Spring Lesson Summary Spring supports loose coupling between components Promotes technique of coding to interfaces, rather than concrete implementation classes This by itself is an important design technique, Provides support for initialization of beans and their dependencies through configuration Can be done using XML configuration files Dependency Injection is used by the Spring container to inject bean dependencies based on configuration data Allows complete decoupling of your code from concrete implementation types Copyright LearningPatterns Inc. All rights reserved. 67

76 Session 6: Spring with Java Web Applications Session 6: Integrating Spring with Java Web Applications Integrate the Spring container with Java Web Apps Copyright LearningPatterns Inc. All rights reserved. 311

77 Session 6: Spring with Java Web Applications Spring and Java EE Java EE (Enterprise Edition): Standard Java architecture for building scalable, distributed, reliable, Enterprise apps Enterprise Edition basically means "Server Side" Java Spring can complement or replace many parts of Java EE Often useful to integrate existing web apps with Spring Fairly easy to integrate the Spring container with the Web container This integration is used in many areas Spring MVC uses the integration technique we'll cover here Can also use Spring beans and DI with standard Java Web apps Java EE applications normally have many components Spring can replace or augment some of the functionality to produce code that is easier to use and maintain Copyright LearningPatterns Inc. All rights reserved. 312

78 Session 6: Spring with Java Web Applications Web Application Structure Java web apps are organized in the standard structure below <Web application base directory> [static content files: HTML, forms, images, etc.] [dynamic content: e.g. JSP] [other content directories] WEB-INF web.xml Web application classes configuration file [.class files: servlets and others] lib [JAR files] The WEB-INF directory is just a normal directory of this name It s an unusual name, but don t be confused by that It was chosen so its name is unlikely to conflict with a name in your web app structure It s still just a normal directory Copyright LearningPatterns Inc. All rights reserved. 313

79 Session 6: Spring with Java Web Applications ApplicationContext and Java Web Apps Spring's WebApplicationContext provides integration with the Java Web container This is a context tailored for Web app use Spring's ContextLoaderListener makes loading the context easy Automatically loads the context when the web app is deployed You can define the Spring configuration file locations using a <context-param> element in web.xml WebApplicationContextUtils class is used to access the context in your web app code Via the static method getwebapplicationcontext() If using standard Java Web apps The following slides shows examples of doing this We'll see when we discuss Spring MVC, there can be multiple application contexts in a Web application The one started up by the ContextLoaderListener is the root of all these application contexts It is available to all other application contexts There are other ways of getting the application context besides using WebApplicationContextUtils However, this is the easiest and most general way By default, ConextLoaderListener loads the configuration file from "/WEB- INF/applicationContext.xml" You can specify your own location using <context-param> Copyright LearningPatterns Inc. All rights reserved. 314

80 Session 6: Spring with Java Web Applications Configuring ContextLoaderListener The web.xml below configures the ContextLoaderListener It specifies applicationcontext.xml and inmemoryitemdao.xml as config files via <context-param> <web-app... > <context-param> <!-- config files for ContextLoaderListener --> <param-name>contextconfiglocation</param-name> <param-value> /WEB-INF/applicationContext.xml /WEB-INF/inMemoryItemDAO.xml </param-value> </context-param> <listener> <!-- Load root application context at startup --> <listener-class> org.springframework.web.context.contextloaderlistener </listener-class> </listener> </web-app> If you don't specify the contextconfiglocation context parameter, the ContextLoaderListener will load a file called /WEB-INF/applicationContext.xml Once the context files are loaded, Spring creates a WebApplicationContext object based on the bean definitions and stores it in the ServletContext of the web application. You can also use Java-based configuration with a Web app by replacing the Web application context with a different one, as follows: <context-param> <param-name>contextclass</param-name> <param-value> org.springframework.web.context.support.annotationconfigwebapplicationcontext </param-value> </context-param> <context-param> <param-name>contextconfiglocation</param-name> <param-value>com.acme.appconfig</param-value> </context-param> Copyright LearningPatterns Inc. All rights reserved. 315

81 Session 6: Spring with Java Web Applications Using the Application Context Below, we retrieve the context via WebApplicationContextUtils This is the context loaded by the ContextLoaderListener Bean look up is the same as in non-web related code The example assumes the same configuration and beans as in our JavaTunes labs earlier in the course You can see - it's very easy to use Spring with Web apps For other frameworks, like Spring MVC, integration is even easier * import org.springframework.web.context.support.webapplicationcontextutils; import org.springframework.web.context.webapplicationcontext; public class SearchServlet extends HttpServlet { public void dopost(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException { } WebApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext( getservletcontext()); Catalog cat = ctx.getbean("javatunescatalog", Catalog.class); The application context that is initialized by ContextLoaderListener is a WebApplicationContext This interface extends ApplicationContext, and adds Web specific functionality, including the ability to define beans in specific scopes For example, if you wanted to define a catalog bean in the session scope, then you could as follows <bean id="javatunescatalog" class="com.javatunes.catalog.javatunescatalog" scope="session"> The Spring container will create a brand new instance of the JavaTunesCatalog bean using the 'javatunescatalog' bean definition for the lifetime of a single HTTP Session There are also request, and globalsession scopes See the reference manual and documentation Spring MVC uses the same context listener to integrate the Spring and Java Web containers It does this transparently to you, and you don't have to use WebApplicationContextUtils This is beyond the scope of this section Copyright LearningPatterns Inc. All rights reserved. 316

82 Lab 6.1: Spring and the Web Lab 6.1 Spring and the Web Copyright LearningPatterns Inc. All rights reserved. 317

83 Lab 6.1: Spring and the Web Lab 6.1 Spring and the Web Lab Overview: In this lab, we will integrate the Spring container with a regular Java Web application We will need to set up our Web server (Tomcat) We will then configure the ContextLoaderListener in web.xml, and use the application context in a servlet We'll look up a Spring bean (a catalog) that's used in a JSP page Objectives: Configure ContextLoaderListener Use an application context from a servlet Builds on previous labs: none Approximate Time: minutes Copyright LearningPatterns Inc. All rights reserved. 318

84 Lab 6.1: Spring and the Web The JavaTunes Online Store Lab The Web application we are creating is a small piece of the JavaTunes online music store It displays a search form The search form sends a request to a servlet that does a search and forwards to a results page that displays the results We are working with the servlet processing the search request The flow for JavaTunes appears at right The first thing we'll do is set up the environment and the Tomcat Web server User submits the search form SearchServlet searchresults.jsp Search results page displayed in browser Copyright LearningPatterns Inc. All rights reserved. 319

85 Lab 6.1: Spring and the Web Eclipse and Web Projects Lab Dynamic Web Projects used for Java Web apps in Eclipse These contain servlets, JSP pages, and static resources (HTML) Web-specific project properties can be establish when creating the project web.xml has a custom editor for ease of use Projects are organized in the following folders src: Contains all Java source files WebContent: Contains all Web resources WebContent\WEB-INF: Same as Java EE WEB-INF Also contains Spring configuration files, other config files This is different from a standard Java EE Web app When deployed, a standard WAR is build All visible elements in the project are not necessarily deployed with the project e.g. the src folder is not deployed - only compiled classes Eclipse creates a standard WAR file when it deploys the project The src folder contains all Java source - including servlets, supporting classes, and JavaBeans The compiled output is put in the WEB-INF\classes directory The WebContent folder contains all Web resources - HTML files, JSP files, image files, etc. Only content in this folder (or a sub-folder) can be accessed in the Web application HTML and JSP pages must be correctly placed relative to the context root Media files, JAR files, loose class files and other resource libraries must also be correctly placed Both the Web and Java EE views are useful for managing Web projects Web perspective contains HTML/JSP oriented views not in J2EE perspective The web.xml file holds many settings Servlets to be run in project Initial (welcome) pages and error pages Environment values and JNDI references to resources made in servlets/jsp s Copyright LearningPatterns Inc. All rights reserved. 320

86 Lab 6.1: Spring and the Web Lab Directory Structure Lab The labs in this section are structured as follows: LabNN : Directory for Lab NN LabNN/src/ : Java source LabNN/WebContent/ : jsp, HTML LabNN/WEB-INF/: web.xml, other config files LabNN/WEB-INF/lib: jar files needed by the Web app For these labs, which are deployed in a war file to a server, the dependencies are included in the project Including the jars that are in the Spring library you add to the project This is how Eclipse organizes the Dynamic Web Project These jar files will end up in WEB-INF/lib in the war file once you deploy the Web app This is the standard place for them in the Java EE WAR packaging Copyright LearningPatterns Inc. All rights reserved. 321

87 Lab 6.1: Spring and the Web Lab Preparation Lab The root lab directory where you will do all your work is: C:\StudentWork\Spring\workspace\Lab06.1 This is a new lab directory which already exists in your workspace Tasks to Perform Close all open files and projects Open the Java EE perspective, by clicking the Perspective icon at the top right of the Workbench, and select Java EE This perspective is well suited for these labs Copyright LearningPatterns Inc. All rights reserved. 322

88 Lab 6.1: Spring and the Web Creating a Server Lab We will use Tomcat to run our Web applications - first we need to create a server in Eclipse * Tasks to Perform 1. Go to the Servers view, right click, and select New Server 2. In the next dialog, select Apache Tomcat V7.0 * and click Next 3. In the next dialog, browse to your Tomcat install directory, click OK, and then Finish * Make sure that Tomcat is installed likely in a directory such as C:\apache-tomcat If its been installed in a different directory, you'll need to modify the instructions in the lab to refer to your install directory If it isn't installed, you'll need to download then install it Download it from: If you use a Tomcat version other than 7.0, then select the appropriate version in the dialog where you choose the server Eclipse for Java EE has support for deploying Web applications to a configured server It also has support to start and stop the servers from within Eclipse If you click Next instead of Finish in Step 3, you'll come to a dialog that lets you configure the project to run on the server We are going to do this slightly differently Copyright LearningPatterns Inc. All rights reserved. 323

89 Lab 6.1: Spring and the Web Configure Server Lab We will reconfigure the deploy location for our server This will help prevent Eclipse deploy issues we've seen (see notes) Tasks to Perform In Servers view, double click on the Tomcat server The server configuration should open in the editor pane Check the "Use Tomcat installation" choice (see below) Save the configuration The default integration with Tomcat deploys to a location in the workspace (under the.metadata folder) We've sometimes seen issues where this creates intermittent problems in deploying Web applications Changing the deploy location to use your actual Tomcat install folder seems to reduce or eliminate these problems Accordingly, we tell you how to change the deploy location to the Tomcat install folder in this slide Copyright LearningPatterns Inc. All rights reserved. 324

90 Lab 6.1: Spring and the Web Create a Web Project Lab Tasks to Perform Create a new Dynamic Web project (as at right) File New Dynamic Web Project * Call it Lab06.1 * Make sure the Tomcat runtime is selected and Click Next In the next dialog, change the Context Root to javatunes (all lower case - as below) Click Finish There are multiple ways to create a new project: Click on the New Wizard button in left side of the toolbar Right click in the Package Explorer View, select New... etc. Copyright LearningPatterns Inc. All rights reserved. 325

91 Lab 6.1: Spring and the Web Configure Build Path Lab We need to add the Spring library (including the web support) to our project classpath to allow the Web app to compile/run properly Tasks to Perform Right click on the project in Project Explorer, select Build Path Configure Build Path, add the Spring library as for other projects Next, click Deployment Assembly in the left pane (for configuring Web app deployment dependencies) Click Apply if prompted to save modifications Click Add Java Build Path Entries click Next, select the Spring library, click Finish, then OK Review the jars in the Spring library (in your Eclipse project) Note the jars that support the Spring/Web integration e.g. jars from Spring like spring-web release.jar, and the springweb-servlet jar There are others in the dependencies we supply - e.g. the JSTL jar Copyright LearningPatterns Inc. All rights reserved. 326

92 Lab 6.1: Spring and the Web Configure ContextLoaderListener Lab Tasks to Perform Note: All Web content (JSP files, WEB-INF folder, ) appears in the Project Explorer pane under the WebContent folder Open up WEB-INF\web.xml for editing Locate the <context-param> element and add in the values for the elements shown below: <param-name>: contextconfiglocation <param-value>: /WEB-INF/applicationContext.xml /WEB-INF/inMemoryItemDAO.xml Locate the <listener> element and add in the following value for the <listener-class> element: org.springframework.web.context.contextloaderlistener Copyright LearningPatterns Inc. All rights reserved. 327

93 Lab 6.1: Spring and the Web Finish SearchServlet Lab Tasks to Perform Open com.javatunes.web.searchsevlet for editing Notice the Spring imports for the web context classes Find dopost(), & initialize the WebApplicationContext by calling the static WebApplicationContextUtils method getrequiredwebapplicationcontext() (See manual slides) Pass in a servlet context retrieved via getservletcontext() Review the rest of the dopost() code It uses the context to look up a Catalog It uses the catalog to do keyword based search Using a keyword from a search form a web page Search results are put on the request under the name "results" The request is forwarded to /jsp/searchresults.jsp for display * You can look at the jsp/header.jspf, and jsp/searchresults.jsp files also if you want They contain the search form and the search results display page respectively The search form contains a bunch of HTML to make it display nicely, but is basically just a form with a single input field, as shown below: <form method='post' action='/javatunes/search'> <input size='20' type='text' name='keyword'/><br/> <input type='submit' name='submit' value='search'/> </form> The SearchServlet is configured in web.xml with a url of /search, and so this form is processed by the search servlet - which puts a collection of MusicItem on the request with the name of "results" searchresults.jsp contains a number of JSTL tags that iterate over the results collection, displaying the data on each MusicItem in the results Copyright LearningPatterns Inc. All rights reserved. 328

94 Lab 6.1: Spring and the Web Deploying an Application Lab Tasks to Perform To deploy to the server, right click on the Lab06.1 project, and select Run As Run on Server In the next dialog box select your existing Tomcat server Also select Set server as project default, as we will always use this server Click Finish Note that running a Web app on the server will automatically start the server We have experienced some situations where the Web application does not deploy correctly for some reason In these cases, the following steps sometimes correct the problem In the Servers view, right click on the server, select Add and Remove Projects Remove the Lab06.1 project Restart the server (Right click on the server, select Restart) Add the project back into the server (Right click on the server, Add and Remove Projects, add Lab06.1) Restart the server again Try browsing to your web app Copyright LearningPatterns Inc. All rights reserved. 329

95 Lab 6.1: Spring and the Web Viewing the Web Application Lab Eclipse should open a browser for you onto the Web app At: Note: Eclipse uses the system default browser, often IE, and IE can be misleading as it caches pages, and it's hard to clear the cache If you ever feel your having browser issues, open an external browser viewing the same URL (see notes about setting the browser in Eclipse) Tomcat listens on port 8080 by default You can also change the Web browser that Eclipse uses Go to the Eclipse Preferences, and navigate to General Web Browser Generally, your standard Web browsers will be detected otherwise you'll need to add them The example below uses an external Firefox browser an external browser is easier to control in terms of caching than the internal one, and Firefox is also easier than IE Copyright LearningPatterns Inc. All rights reserved. 330

96 Lab 6.1: Spring and the Web Test Your Application Lab Tasks to Perform The javatunes web app, displays a search form - so type in the letter "a" to search on and submit the form The SearchServlet will be invoked, use your Spring beans to do the search, and then forward to a JSP to display the results That's it - you're using Spring in a Web application Copyright LearningPatterns Inc. All rights reserved. 331

97 Lab 6.1: Spring and the Web Server Startup Lab You can open the Console view to see output from the server startup and web app deployment This can be useful to look for exception stack traces Note that server startup may take some time, especially the first time you start the server You can also look at the server status in the Servers view STOP Copyright LearningPatterns Inc. All rights reserved. 332