Beginning Spring.
Title:
Beginning Spring.
Author:
Caliskan, Mert.
ISBN:
9781118893111
Personal Author:
Edition:
1st ed.
Physical Description:
1 online resource (544 pages)
Contents:
Beginning Spring -- CONTENTS -- FOREWORDS -- INTRODUCTION -- CHAPTER 1: POJO PROGRAMMING MODEL, LIGHTWEIGHT CONTAINERS, AND INVERSION OF CONTROL -- POJO Programming Model -- Problems of the Old EJB Programming Model -- Benefits of the POJO Programming Model -- Lightweight Containers and Inversion of Control (IoC) -- Lightweight Containers -- Inversion of Control (IoC) -- Dependency Injection -- Setter Injection -- Constructor Injection -- Setter or Constructor Injection -- Summary -- CHAPTER 2: DEPENDENCY INJECTION WITH SPRING -- Spring IoC Container -- Configuration Metadata -- Configuring and Using the Container -- Dependency Injection -- Setter Injection -- Constructor Injection -- Circular Dependencies -- Dependency Resolution Process -- Overriding Bean Definitions -- Using the depends-on Attribute -- Autowiring -- Bean Lookups -- Spring-Managed Beans -- Naming Beans -- Bean Instantiation Methods -- Bean Scopes -- Lazy Initialization -- Life-Cycle Callbacks -- Bean Definition Profiles -- Environment -- Summary -- CHAPTER 3: BUILDING WEB APPLICATIONS USING SPRING MVC -- Learning the Features and Benefits of Spring MVC -- Using the Dispatcher Servlet Mechanism -- Defining the Servlet -- Accessing Servlet Context -- Creating Your First Spring MVC Application -- Configuring Spring MVC with Annotations -- Handling Forms with JSP -- Configuring the Form Tag Library -- Understanding the Power of Binding -- Working with Forms -- Using Input Elements -- Entering Dates -- Selecting from a Drop-Down -- Selecting with Radio Buttons -- Selecting with Checkboxes -- Adding Labels -- Placing Buttons -- Styling -- Exploiting the Power of Annotations -- @Controller -- @RequestMapping -- @ModelAttribute -- @PathVariable -- @ControllerAdvice -- @InitBinder -- @ExceptionHandler -- Validating User Input -- Uploading Files -- Handling Exceptions.
Implementing Internationalization (i18n) -- Using Themes -- Summary -- CHAPTER 4: JDBC DATA ACCESS WITH SPRING -- Problems with Using Vanilla JDBC -- Introducing Spring's JDBC Support -- Managing JDBC Connections -- Embedded DB Support -- Using a Connection-Pooled DataSource -- Initializing DB -- Configuring and Using Spring's JDBC Support -- Performing Data Access Operations with Spring -- Running Queries -- Queries with Named Parameters -- Writing Queries Using the IN Clause -- Using PreparedStatements within JdbcTemplate -- Inserting, Updating, and Deleting Records -- Calling Stored Procedures and Stored Functions -- Performing Batch Operations -- Handling BLOB and CLOB Objects -- Accessing Vendor-Specific JDBC Methods -- Executing DDL Operations -- Modeling JDBC Operations as Java Objects -- Encapsulating SQL Query Executions -- Encapsulating SQL DML Operations -- Encapsulating Stored Procedure Executions -- Exception Handling and Error Code Translation -- Common Data Access Exception Hierarchy -- Automatic Handling and Translation of SQLException -- Summary -- CHAPTER 5: DATA ACCESS WITH JPA USING SPRING -- Brief Introduction to ORM and JPA -- Paradigm Mismatch -- Building Blocks of an ORM Framework -- What JPA Offers -- Mapping the Object Model to the Relational Model -- Defining Entities -- Mapping Attributes to Columns -- Creating Associations between Objects -- Mapping Java Types to SQL Types -- Configuring and Using JPA -- Performing CRUD Operations on Objects -- Querying with Object Query Language -- Spring's JPA Support -- Setting Up JPA in Spring Container -- Implementing DAOs Based on Plain JPA -- Handling and Translating Exceptions -- Further JPA Configuration in Spring Environment -- JpaDialect -- JpaVendorAdapter -- JPA and Load Time Weaving -- Dealing with Multiple Persistence Units -- Summary.
CHAPTER 6: MANAGING TRANSACTIONS WITH SPRING -- Understanding Transaction Management -- Spring's Transaction Abstraction Model -- Local versus Global Transactions -- PlatformTransactionManager Implementations -- Advantages of Spring's Abstract Transaction Model -- Declarative Transaction Management with Spring -- Isolating the Service Layer from Data Access Technology Details -- Customizing Default Transactional Behavior -- Using @Transactional on the Class Level -- Understanding Transaction Propagation Rules -- Propagation REQUIRED -- Propagation REQUIRES_NEW -- Propagation NESTED -- Propagation SUPPORTS -- Propagation NOT_SUPPORTED -- Propagation NEVER -- Propagation MANDATORY -- Using for Declarative Transaction Management -- Programmatic Transaction Management with Spring -- Using the PlatformTransactionManager Approach -- Executing Custom Logic Before or After Transactions -- Advising Transactional Operations -- Executing Logic after Transactions Using TransactionSynchronization -- Summary -- CHAPTER 7: TEST-DRIVEN DEVELOPMENT WITH SPRING -- Configuring and Caching ApplicationContext -- Using XML- and Java-Based Context Configuration in Tests -- Configuring Context with ApplicationContextInitializer -- Inheriting Context Configuration -- ApplicationContext Caching -- Injecting Dependencies of Test Fixtures -- Using Transaction Management in Tests -- Testing Web Applications -- Context Hierarchies in Tests -- Testing Request- and Session-Scoped Beans -- Testing Spring MVC Projects -- Testing Controllers -- Testing Form Submit -- Testing Exception Handlers -- Printing Mock Request and Response -- Using Mock Objects and Other Utilities for Testing -- Spring Provided Mock Objects for Testing -- Other Utilities and Test Annotations -- Summary -- CHAPTER 8: ASPECT-ORIENTED PROGRAMMING WITH SPRING -- Getting Started with AOP with Spring.
Becoming Familiar with Types of Advices -- Before -- After Returning -- After Throwing -- After (Finally) -- Around -- Defining Point-Cut Designators -- The Type Signature Expressions -- The Method Signature Expressions -- Other Alternative Point-Cut Designators -- Wildcards -- Capitalizing on the Power of Annotations -- @Before -- @Pointcut -- @After -- @AfterReturning -- @AfterThrowing -- @Aspect -- @Around -- @DeclareParents -- Blending AspectJ with Spring -- Configuring Spring AOP with Annotations -- Summary -- CHAPTER 9: SPRING EXPRESSION LANGUAGE -- Configuring Applications with SpEL -- Creating a Parser -- Invoking Methods -- Calling Constructors -- Calling Static Methods -- Working with Variables and Functions -- #root -- #this -- Accessing System Properties and Environment -- Inline Lists -- Registering Functions -- Understanding SpEL Operators -- Relational Operators -- Arithmetic Operators -- Logical Operators -- Conditional Operators -- Regular Expression Operator -- Safe Navigation Operator -- Collection Selection and Projection -- Selecting the First and Last Element of a Collection -- Using Utilities in SpEL -- Accessing Spring Beans -- -- Expressions in Caching -- Summary -- CHAPTER 10: CACHING -- Building Your First Caching Application -- Configuring the Cache Manager with a Different Name -- Configuring the Caching Abstraction with Annotations -- Working with Cache Annotations -- @Cacheable -- Key Generator -- Conditional Caching -- @CacheEvict -- @CachePut -- @Caching -- Implementing Cache Managers -- SimpleCacheManager -- NoOpCacheManager -- ConcurrentMapCacheManager -- CompositeCacheManager -- Casting Your SpEL on Caches -- Initializing Your Caches Programmatically -- Finding Alternative Cache Providers -- Ehcache -- Guava -- Hazelcast -- Summary -- CHAPTER 11: RESTFUL WEB SERVICES WITH SPRING.
Creating Your First REST Web Service -- Returning Different HTTP Status Codes from REST Web Service -- Learning an Annotation-Based Configuration Alternative -- Using REST Web Services with XML -- Using the Exception Handling Mechanism -- Unit Testing RESTful Services -- Summary -- CHAPTER 12: SECURING WEB APPLICATIONS WITH SPRING SECURITY -- Why Spring Security? -- Features of Spring Security -- Configuring and Using Spring Security -- Understanding the Fundamental Building Blocks of Spring Security -- Authenticating Users -- Unsuccessful Login Flow -- Successful Login Flow -- Anonymous Authentication -- Customizing the Login Page -- Logout Process -- Accessing UserDetails Using JDBC -- Encrypting Passwords -- Remember-Me Support -- User Session Management -- Basic Authentication -- Authorizing Web Requests and Service Method Calls -- Authorizing Web Requests -- How Does Authorization Work? -- Expression-Based Authorization -- Using JSP Security Tags -- Authorize Tag -- Authenticate Tag -- Authorizing Service Methods -- Summary -- CHAPTER 13: NEXT STOP: SPRING 4.0 -- Keeping Up with the Latest: Java 8 and Java EE7 Support -- Lambda Expressions -- Method References -- Bean Validation Integration -- JSR 310: Date Time Value Type Support -- Configuring Injection with Conditional Dependency -- Ordering the Elements of Autowired Collections -- Repeating Annotations -- Introducing New Annotations -- Documenting with @Description -- Using the @RestController Annotation -- Summary -- APPENDIX: SOLUTIONS TO EXERCISES -- INDEX -- EULA.
Abstract:
Get up to speed quickly with this comprehensive guide to Spring Beginning Spring is the complete beginner's guide to Java's most popular framework. Written with an eye toward real-world enterprises, the book covers all aspects of application development within the Spring Framework. Extensive samples within each chapter allow developers to get up to speed quickly by providing concrete references for experimentation, building a skillset that drives successful application development by exploiting the full capabilities of Java's latest advances. Spring provides the exact toolset required to build an enterprise application, and has become the standard within the field. This book covers Spring 4.0, which contains support for Java 8 and Java EE 7. Readers begin with the basics of the framework, then go on to master the most commonly used tools and fundamental concepts inherent in any Spring project. The book emphasizes practicality and real-world application by addressing needs such as meeting customer demand and boosting productivity, and by providing actionable information that helps developers get the most out of the framework. Topics include: Dependency Injection and Inversion of Control Unit testing Spring enabled Web Applications Data Access using Spring JDBC and ORM support along with Transaction Management Building Web Applications and RESTful Web Services with Spring MVC Securing Web Applications using Spring Security Spring Expression Language with its Extensive Features Aspect Oriented Programming Facilities Provided by Spring AOP Caching with 3rd Party Cache Providers' Support The Best of the Breed: Spring 4.0 The information is organized and structured an ideal way for students and corporate training programs, and explanations about inner workings of the framework make it a handy desk reference even for experienced developers. For
novices, Beginning Spring is invaluable as a comprehensive guide to the real-world functionality of Spring.
Local Note:
Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2017. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.
Genre:
Electronic Access:
Click to View