book

Spring Recipes: A Problem-Solution Approach, Third Edition

by Marten Deinum, Josh Long, Gary Mak, Daniel Rubio

November 2014

Intermediate to advanced

808 pages

22h 47m

English

Apress

Read now

Unlock full access

1-1. Build a Spring application with the Spring Tool SuiteProblemSolutionHow It Works1-2. Build a Spring application with the Eclipse IDEProblemSolutionHow It Works1-3. Build a Spring application with the IntelliJ IDEProblemSolutionHow It Works1-4. Build a Spring application with the Maven command line interfaceProblemSolutionHow It Works1-5. Build a Spring application with the Gradle command line interfaceProblemSolutionHow It Works1.6 Build a Spring application with the Gradle WrapperProblemSolutionHow It WorksSummary
2-1. Manage and Configure POJOs with the Spring IoC ContainerProblemSolutionHow It Works2-2. Create POJOs by Invoking a ConstructorProblemSolutionHow It Works2-3. Use POJO References, Auto-Wiring, and Imports to Interact with Other POJOsProblemSolutionHow It Works2-4. Configure POJOs with Java Collection AttributesProblemSolutionHow It Works2-5. Set a POJOs ScopeProblemSolutionHow It Works2-6. Use Data from External Resources (Text Files, XML Files, Properties Files, or Image Files)ProblemSolutionHow It Works2-7. Resolve I18N Text Messages for Different Locales in Properties FilesProblemSolutionHow It Works2-8. Customize POJO Initialization and DestructionProblemSolution2-9. Create Post Processors to Validate and Modify POJOsProblemSolutionHow It Works2-10. Create POJOs with a Factory (Static Method, Instance Method, Spring’s FactoryBean)ProblemSolutionHow It Works2-11. Use Spring Environments and Profiles to Load Different Sets of POJOsProblemSolutionHow It Works
ProblemSolutionHow It Works2-13. Declare POJOs from Static Fields or Object PropertiesProblemSolutionHow It Works2-14. Making POJOs Aware of Spring’s IoC Container ResourcesProblemSolutionHow It Works2-15. Communicate Application Events Between POJOsProblemSolutionHow It Works2-16. Use Property Editors in SpringProblemSolutionHow It Works2-17. Inherit POJO ConfigurationsProblemSolutionHow It Works2-18. Implement POJOs with Scripting LanguagesProblemSolutionHow It Works2-19. Inject Spring POJOs into ScriptsProblemSolutionHow It Works2-20. Refresh POJOs from ScriptsProblemSolutionHow It Works2-21. Define Script Sources as Inline Code and not in External FilesProblemSolutionHow It Works2-22. Use the Spring Expression Language to Configure POJOsProblemSolutionHow It WorksSummary
3-1. Using Java Config to configure POJOsProblemSolutionHow It Works3-2. Create POJOs by Invoking a ConstructorProblemSolutionHow It Works3-3. Use POJO References and Auto-Wiring to Interact with other POJOsProblemSolutionHow It Works3-4. Auto-wire POJOs the @Resource and @Inject annotationProblemSolutionHow It Works3-5. Set a POJOs Scope with the @Scope annotationProblemSolutionHow It Works3-6. Use data from External Resources (Text files, XML files, properties files, or image files)ProblemSolutionHow It Works3-7. Resolve I18N Text Messages for different locales in properties filesProblemSolutionHow It Works3-8. Customize POJO Initialization and Destruction with annotationsProblemSolutionHow It Works3-9. Create Post Processors to validate and modify POJOsProblemSolutionHow It Works3-10. Create POJOs with a factory (Static method, Instance method, Spring’s FactoryBean)ProblemSolutionHow It Works3-11. Use Spring Environments and Profiles to load different sets of POJOsProblemSolutionHow it works3-12. Aspect Orientated programming with AnnotationsProblemSolutionHow It Works3-13. Accessing the Join Point InformationProblemSolutionHow It Works3-14. Specifying Aspect Precedence with the @Order annotationProblemSolutionHow It Works3-15. Reuse Aspect Pointcut DefinitionsProblemSolutionHow It Works3-16. Writing AspectJ Pointcut ExpressionsProblemSolutionHow It Works3-17. AOP introductions for POJOsProblemSolutionHow It Works
ProblemSolutionHow It Works3-19. Load-Time Weaving AspectJ Aspects in SpringProblemSolutionHow It Works3-20. Configuring AspectJ Aspects in SpringProblemSolutionHow It Works3-21. Inject POJOs into Domain Objects with AOPProblemSolutionHow It Works3-22. Concurrency with Spring and TaskExecutorsProblemSolutionHow It WorksSummary
4-1. Developing a Simple Web Application with Spring MVCProblemSolutionHow It Works4-2. Mapping requests with @RequestMappingProblemSolutionHow It Works4-3. Intercepting Requests with Handler InterceptorsProblemSolutionHow It Works4-4. Resolving User LocalesProblemSolutionHow It Works4-5. Externalizing Locale-Sensitive Text MessagesProblemSolutionHow It Works4-6. Resolving Views by NamesProblemSolutionHow It Works4-7. Views and Content NegotiationProblemSolutionHow It Works4-8. Mapping Exceptions to ViewsProblemSolutionHow It WorksMappings exceptions using @ExceptionHandler4-9. Handling Forms with ControllersProblemSolutionHow It Works4-10. Bean validation with Annotations (JSR-303)ProblemSolutionHow It Works4-11. Creating Excel and PDF ViewsProblemSolutionHow It WorksSummary
5-1. Publishing XML with REST ServicesProblemSolutionHow It Works5-2. Publishing JSON with REST servicesProblemSolutionHow It Works5-3. Accessing a REST Service with SpringProblemSolutionHow It Works5-4. Publishing RSS and Atom feedsProblemSolutionHow It WorksSummary
6-1. Setting Up Spring SocialProblemSolutionHow It Works6-2. Connecting to TwitterProblemSolutionHow It Works6-3. Connecting to FacebookProblemSolutionHow It Works6-4. Showing Service Provider Connection StatusProblemSolutionHow It Works6-5. Using the Twitter APIProblemSolutionHow It Works6-6. Using a Persistent UsersConnectionRepositoryProblemSolutionHow It Works6-7. Integrating Spring Social and Spring SecurityProblemSolutionHow It WorksSummary
7-1. Securing URL AccessProblemSolutionHow It Works7-2. Logging In to Web ApplicationsProblemSolutionHow It Works7-3. Authenticating UsersProblemSolutionHow It Works7-4. Making Access Control DecisionsProblemSolutionHow It Works7-5. Securing Method InvocationsProblemSolutionHow It Works7-6. Handling Security in ViewsProblemSolutionHow It Works7-7. Handling Domain Object SecurityProblemSolutionHow It WorksSummary
Recipe 8-1. Device detection without Spring MobileProblemSolutionHow It WorksRecipe 8-2. Device detection with Spring MobileProblemSolutionHow It Works8-3. Using Site preferencesProblemSolutionHow It Works8-4. Using the Device Information to Render ViewsProblemSolutionHow It Works8-5. Site SwitchingProblemSolutionHow It WorksSummary
9-1. Accessing Spring in Generic Web ApplicationsProblemSolutionHow It Works9-2. Using Spring in Your Servlets and FiltersProblemSolutionHow It Works9-3. Integrating Spring with JSFProblemSolutionHow It WorksSummary
Problems with Direct JDBCSetting Up the Application DatabaseUnderstanding the Data Access Object Design PatternImplementing the DAO with JDBCConfiguring a Data Source in SpringRunning the DAOTaking It a Step Further10-1. Using a JDBC Template to Update a DatabaseProblemSolutionHow It Works10-2. Using a JDBC Template to Query a DatabaseProblemSolutionHow It Works10-3. Simplifying JDBC Template CreationProblemSolutionHow It Works10-4. Using Named Parameters in a JDBC TemplateProblemSolutionHow It Works10-5. Handling Exceptions in the Spring JDBC FrameworkProblemSolutionHow It Works10-6. Problems with Using ORM Frameworks DirectlyProblemSolutionHow It WorksPersisting Objects Using the Hibernate API with Hibernate XML MappingsPersisting Objects Using the Hibernate API with JPA AnnotationsPersisting Objects Using JPA with Hibernate as the Engine10-7. Configuring ORM Resource Factories in SpringProblemSolutionHow It Works10-8. Persisting Objects with Spring’s ORM TemplatesProblemSolutionHow It Works10-9. Persisting Objects with Hibernate’s Contextual SessionsProblemSolutionHow It Works10-10. Persisting Objects with JPA’s Context InjectionProblemSolutionHow It Works10-11. Simplify JPA with Spring Data JPAProblemSolutionHow It WorksSummary
11-1. Problems with Transaction Management11-2. Choosing a Transaction Manager ImplementationProblemSolutionHow It Works11-3. Managing Transactions Programmatically with the Transaction Manager APIProblemSolutionHow It Works11-4. Managing Transactions Programmatically with a Transaction TemplateProblemSolutionHow It Works11-5. Managing Transactions Declaratively with Transaction AdvicesProblemSolutionHow It Works11-6. Managing Transactions Declaratively with the @Transactional AnnotationProblemSolutionHow It Works11-7. Setting the Propagation Transaction AttributeProblemSolutionHow It Works11-8. Setting the Isolation Transaction AttributeProblemSolutionHow It Works11-9. Setting the Rollback Transaction AttributeProblemSolutionHow It Works11-10. Setting the Timeout and Read-Only Transaction AttributesProblemSolutionHow It Works11-11. Managing Transactions with Load-Time WeavingProblemSolutionHow It WorksSummary
Runtime Metadata Model12-1. Setting Up Spring Batch’s InfrastructureProblemSolutionHow It Works12-2. Reading and WritingProblemSolutionHow It Works12-3. Writing a Custom ItemWriter and ItemReaderProblemSolutionHow It Works12-4. Processing Input Before WritingProblemSolutionHow It Works12-5. Better Living through TransactionsProblemSolutionHow It Works12-6. RetryingProblemSolutionHow It Works12-7. Controlling Step ExecutionProblemSolutionHow It Works12-8. Launching a JobProblemSolutionHow It Works12-9. Parameterizing a JobProblemSolutionHow It WorksSummary
13-1. Using MongoDBProblemSolutionHow It Works13-2. Using Redis13-3. Using HadoopProblemSolutionHow It Works13-4. Using Neo4jProblemSolutionHow It WorksSummary
14-1.Register Spring POJOs as JMX MBeansProblemSolutionHow It Works14-2. Publish and Listen to JMX NotificationsProblemSolutionHow It Works14-3. Access Remote JMX MBeans in SpringProblemSolutionHow It Works14-4. Send E-mail with Spring’s E-mail SupportProblemSolutionHow It Works14-5. Schedule tasks with Spring’s Quartz SupportProblemSolutionHow It Works14-6. Schedule tasks with Spring’s SchedulingProblemSolutionHow It Works14-7. Expose and Invoke Services through RMIProblemSolutionHow It Works14-8. Expose and Invoke Services through HTTPProblemSolutionHow It Works14-9. Expose and invoke SOAP Web Services with JAX-WSProblemSolutionHow It Works14-10. Introduction to contract first SOAP Web ServicesProblemSolutionHow It Works14-11. Expose and invoke SOAP Web Services with Spring-WSProblemSolutionHow It Works14-12. Develop SOAP Web Services with Spring-WS and XML MarshallingProblemSolutionHow It WorksSummary
15-1. Send and Receive JMS Messages with SpringProblemSolutionHow It Works15-2. Convert JMS MessagesProblemSolutionHow It Works15-3. Manage JMS TransactionsProblemApproachSolution15-4. Create Message-Driven POJOs in SpringProblemSolutionHow It Works15-5. Cache and pool JMS connectionsProblemSolutionHow It Works15-6 Send and Receive AMQP Messages with SpringProblemSolutionHow It WorksSummary
16-1. Integrating One System with Another Using EAIProblemSolutionHow It Works16-2. Integrating Two Systems Using JMSProblemSolutionHow It Works16-3. Interrogating Spring Integration Messages for Context InformationProblemSolutionHow It Works16-4. Integrating Two Systems Using a File SystemProblemSolutionHow It Works16-5. Transforming a Message from One Type to AnotherProblemSolutionHow It Works16-6. Error Handling Using Spring IntegrationProblemSolutionHow It Works16-7. Forking Integration Control: Splitters and AggregatorsProblemSolutionHow It Works16-8. Conditional Routing with RoutersProblemSolutionHow It Works16-9. Staging Events Using Spring BatchProblemSolutionHow It Works16-10. Using GatewaysProblemSolutionHow It WorksSummary
17-1. Creating Tests with JUnit and TestNGProblemSolutionHow It Works17-2. Creating Unit Tests and Integration TestsProblemSolutionHow It Works17-3. Unit Testing Spring MVC ControllersProblemSolutionHow It Works17-4. Managing Application Contexts in Integration TestsProblemSolutionHow It Works17-5. Injecting Test Fixtures into Integration TestsProblemSolutionHow It Works17-6. Managing Transactions in Integration TestsProblemSolutionHow It Works17-7. Accessing a Database in Integration TestsProblemSolutionHow It Works17-8. Using Spring’s Common Testing AnnotationsProblemSolutionHow It Works17-9. Integration Testing Spring MVC ControllersProblemSolutionHow It WorksSummary
18-1. Getting and Installing GrailsProblemSolutionHow It Works18-2. Creating a Grails ApplicationProblemSolutionHow It Works18-3. Grails Plug-InsProblemSolutionHow It Works18-4. Developing, Producing, and Testing in Grails EnvironmentsProblemSolutionHow It Works18-5. Creating an Application’s Domain ClassesProblemSolutionHow It Works18-6. Generating CRUD Controllers and Views for an Application’s Domain ClassesProblemSolutionHow It Works18-7. Internationalization (I18n) Message PropertiesProblemSolutionHow It Works18-8. Changing Permanent Storage SystemsProblemSolutionHow It Works18-9. LoggingProblemSolutionHow It Works18-10. Running Unit and Integration TestsProblemSolutionHow It Works18-11. Using Custom Layouts and TemplatesProblemSolutionHow It Works18-12. Using GORM QueriesProblemSolutionHow It Works18-13. Creating Custom TagsProblemSolutionHow It Works18-14. Adding SecurityProblemSummary

Content preview from Spring Recipes: A Problem-Solution Approach, Third Edition

CHAPTER 13

NoSQL and BigData

Most applications use a relational database like Oracle, MySQL, or Postgresql; however there is more too data storage then just SQL databases. There are:

Relational Databases (Oracle, Mysql, Postgresql, etc.)
Document Stores (MongoDB, Couchbase)
Key-Value Stores (Redis, Volgemort)
Column Stores (Cassandra)
Graph Stores (Neo4j, Giraph)

Although each of these different technologies (and even the different implementations) have their own use, they can also be hard to use or configure. Additionally, sometimes it might feel that one writes a lot of duplicated plumbing code for handling transactions and error translation. ...