没有合适的资源?快使用搜索试试~ 我知道了~
首页精通Spring 5:企业级应用开发全面指南
精通Spring 5:企业级应用开发全面指南
需积分: 9 5 下载量 117 浏览量
更新于2024-07-18
1
收藏 9.52MB PDF 举报
"Pro Spring 5 第五版 英文原版是一本全面的Spring框架参考和实践指南,专门针对Spring Framework的第5版。本书涵盖了核心Spring以及它与诸如Hibernate、JPA 2、Tiles、Thymeleaf和WebSocket等其他领先Java技术的集成。重点在于使用Java配置类、lambda表达式、Spring Boot和反应式编程。书中分享了作者在企业应用开发中的见解和实践经验,包括远程调用、事务处理、Web和表现层等多个方面。"
《Pro Spring 5》第五版是深入探索Spring框架及其工具的权威指南,由Iuliana Cosmina、Rob Harrop、Chris Schaefer和Clarence Ho撰写。这本书旨在帮助读者理解和利用Spring Framework 5的所有强大功能,并涵盖了与之相关的各种工具和技术。
在本书中,读者将学习到:
1. **Spring核心**:理解Spring的核心概念,如依赖注入(DI)、AOP(面向切面编程)以及如何通过Java配置类来管理应用的组件。
2. **Lambda表达式**:如何在Spring应用中使用Java 8的lambda表达式,以实现更简洁、更易于理解的代码。
3. **Spring Boot**:深入研究Spring Boot,它是快速构建Spring应用的框架,提供了自动配置和简化部署的功能。
4. **反应式编程**:学习如何在Spring中使用反应式编程模型,以实现非阻塞、高并发的系统设计。
5. **数据访问集成**:探讨Spring与Hibernate、JPA 2的整合,用于高效的数据持久化,以及如何使用Tiles进行视图布局,Thymeleaf作为模板引擎。
6. **Web开发**:了解Spring MVC框架,用于构建现代Web应用,以及如何使用WebSocket进行实时通信。
7. **事务管理**:学习如何在Spring中配置和管理事务,确保数据的一致性和完整性。
8. **远程调用**:掌握Spring提供的远程调用机制,如RMI、HTTP Invoker和Web服务等。
9. **实战经验**:书中包含大量实际案例和最佳实践,帮助读者将理论知识应用于实际项目。
通过《Pro Spring 5》,无论是初学者还是有经验的开发者,都能获得丰富的知识,提升在Spring框架上的专业技能,从而更好地构建和维护高效的企业级Java应用程序。
■ Contents
xvi
Introducing Spring Type Conversion ����������������������������������������������������������������������������� 514
Implementing a Custom Converter ����������������������������������������������������������������������������������������������������� 514
Configuring ConversionService ���������������������������������������������������������������������������������������������������������� 515
Converting Between Arbitrary Types ��������������������������������������������������������������������������������������������������� 517
Field Formatting in Spring �������������������������������������������������������������������������������������������� 521
Implementing a Custom Formatter ����������������������������������������������������������������������������������������������������� 521
Configuring ConversionServiceFactoryBean �������������������������������������������������������������������������������������� 523
Validation in Spring ������������������������������������������������������������������������������������������������������ 524
Using the Spring Validator Interface ��������������������������������������������������������������������������������������������������� 525
Using JSR-349 Bean Validation ���������������������������������������������������������������������������������������������������������� 527
Configuring Bean Validation Support in Spring ����������������������������������������������������������������������������������� 528
Creating a Custom Validator ��������������������������������������������������������������������������������������������������������������� 531
Using AssertTrue for Custom Validation ����������������������������������������������������������������������� 534
Considerations for Custom Validation �������������������������������������������������������������������������� 535
Deciding Which Validation API to Use ��������������������������������������������������������������������������� 535
Summary ���������������������������������������������������������������������������������������������������������������������� 535
■Chapter 11: Task Scheduling ����������������������������������������������������������������������������� 537
Dependencies for the Task Scheduling Samples ��������������������������������������������������������� 537
Task Scheduling in Spring �������������������������������������������������������������������������������������������� 538
Introducing the Spring TaskScheduler Abstraction �����������������������������������������������������������������������������539
Exploring a Sample Task ��������������������������������������������������������������������������������������������������������������������� 540
Using Annotations for Task Scheduling ���������������������������������������������������������������������������������������������� 547
Asynchronous Task Execution in Spring ��������������������������������������������������������������������������������������������� 551
Task Execution in Spring ���������������������������������������������������������������������������������������������� 554
Summary ���������������������������������������������������������������������������������������������������������������������� 556
■Chapter 12: Using Spring Remoting ������������������������������������������������������������������ 557
Using a Data Model for Samples ���������������������������������������������������������������������������������� 558
Adding Required Dependencies for the JPA Back End ������������������������������������������������� 560
■ Contents
xvii
Implementing and Configuring SingerService �������������������������������������������������������������� 562
Implementing SingerService �������������������������������������������������������������������������������������������������������������� 562
Configuring SingerService ������������������������������������������������������������������������������������������������������������������ 564
Exposing the Service �������������������������������������������������������������������������������������������������������������������������� 567
Invoking the Service ��������������������������������������������������������������������������������������������������������������������������� 568
Using JMS in Spring ����������������������������������������������������������������������������������������������������� 570
Implementing a JMS Listener in Spring ��������������������������������������������������������������������������������������������� 573
Sending JMS Messages in Spring ������������������������������������������������������������������������������������������������������ 574
Spring Boot Artemis Starter ����������������������������������������������������������������������������������������� 576
Using RESTful-WS in Spring ����������������������������������������������������������������������������������������� 579
Introducing RESTful Web Services ����������������������������������������������������������������������������������������������������� 579
Adding Required Dependencies for Samples ������������������������������������������������������������������������������������� 580
Designing the Singer RESTful Web Service ���������������������������������������������������������������������������������������� 580
Using Spring MVC to Expose RESTful Web Services ��������������������������������������������������������������������������� 581
Configuring Castor XML ������������������������������������������������������������������������������������������������ 582
Implementing SingerController ����������������������������������������������������������������������������������������������������������� 584
Configuring a Spring Web Application ������������������������������������������������������������������������������������������������ 586
Using curl to Test RESTful-WS ������������������������������������������������������������������������������������������������������������ 590
Using RestTemplate to Access RESTful-WS���������������������������������������������������������������������������������������� 592
Securing RESTful-WS with Spring Security ���������������������������������������������������������������������������������������� 597
RESTful-WS with Spring with Spring Boot ������������������������������������������������������������������� 602
Using AMQP in Spring��������������������������������������������������������������������������������������������������� 605
Using AMQP with Spring Boot ������������������������������������������������������������������������������������������������������������� 611
Summary ���������������������������������������������������������������������������������������������������������������������� 613
■Chapter 13: Spring Testing �������������������������������������������������������������������������������� 615
Introducing Testing Categories ������������������������������������������������������������������������������������� 616
Using Spring Test Annotations �������������������������������������������������������������������������������������� 617
Implementing Logic Unit Tests ������������������������������������������������������������������������������������� 618
Adding Required Dependencies����������������������������������������������������������������������������������������������������������619
Unit Testing Spring MVC Controllers ��������������������������������������������������������������������������������������������������� 620
■ Contents
xviii
Implementing an Integration Test ��������������������������������������������������������������������������������� 623
Adding Required Dependencies����������������������������������������������������������������������������������������������������������623
Configuring the Profile for Service-Layer Testing ������������������������������������������������������������������������������� 623
Java Configuration Version ����������������������������������������������������������������������������������������������������������������� 625
Implementing the Infrastructure Classes �������������������������������������������������������������������������������������������627
Unit Testing the Service Layer ������������������������������������������������������������������������������������������������������������ 630
Dropping DbUnit ��������������������������������������������������������������������������������������������������������������������������������� 634
Implementing a Front-End Unit Test ����������������������������������������������������������������������������� 637
Introducing Selenium ������������������������������������������������������������������������������������������������������������������������� 638
Summary ���������������������������������������������������������������������������������������������������������������������� 638
■Chapter 14: Scripting Support in Spring ����������������������������������������������������������� 639
Working with Scripting Support in Java ����������������������������������������������������������������������� 640
Introducing Groovy ������������������������������������������������������������������������������������������������������� 641
Dynamic Typing ���������������������������������������������������������������������������������������������������������������������������������� 642
Simplified Syntax �������������������������������������������������������������������������������������������������������������������������������� 643
Closure������������������������������������������������������������������������������������������������������������������������������������������������643
Using Groovy with Spring ��������������������������������������������������������������������������������������������� 644
Developing the Singer Domain ����������������������������������������������������������������������������������������������������������� 645
Implementing the Rule Engine������������������������������������������������������������������������������������������������������������646
Implementing the Rule Factory as a Spring Refreshable Bean ���������������������������������������������������������� 648
Testing the Age Category Rule ������������������������������������������������������������������������������������������������������������650
Inlining Dynamic Language Code ������������������������������������������������������������������������������������������������������� 652
Summary ���������������������������������������������������������������������������������������������������������������������� 654
■Chapter 15: Application Monitoring ������������������������������������������������������������������ 655
JMX Support in Spring ������������������������������������������������������������������������������������������������� 655
Exporting a Spring Bean to JMX ����������������������������������������������������������������������������������� 656
Using Java VisualVM for JMX Monitoring ��������������������������������������������������������������������� 657
Monitoring Hibernate Statistics ������������������������������������������������������������������������������������ 659
JMX with Spring Boot ��������������������������������������������������������������������������������������������������� 661
Summary ���������������������������������������������������������������������������������������������������������������������� 664
■ Contents
xix
■Chapter 16: Web Applications ��������������������������������������������������������������������������� 665
Implementing the Service Layer for Samples �������������������������������������������������������������� 666
Using a Data Model for the Samples �������������������������������������������������������������������������������������������������� 666
Implementing the DAO Layer ��������������������������������������������������������������������������������������������������������������670
Implementing the Service Layer ��������������������������������������������������������������������������������������������������������� 670
Configuring SingerService�������������������������������������������������������������������������������������������� 672
Introducing MVC and Spring MVC �������������������������������������������������������������������������������� 673
Introducing MVC ��������������������������������������������������������������������������������������������������������������������������������� 674
Introducing Spring MVC ���������������������������������������������������������������������������������������������������������������������� 675
Spring MVC WebApplicationContext Hierarchy ����������������������������������������������������������������������������������� 675
Spring MVC Request Life Cycle ���������������������������������������������������������������������������������������������������������� 676
Spring MVC Configuration�������������������������������������������������������������������������������������������������������������������678
Creating the First View in Spring MVC ������������������������������������������������������������������������������������������������ 681
Configuring DispatcherServlet ������������������������������������������������������������������������������������������������������������ 683
Implementing SingerController ����������������������������������������������������������������������������������������������������������� 684
Implementing the Singer List View ����������������������������������������������������������������������������������������������������� 685
Testing the Singer List View ���������������������������������������������������������������������������������������������������������������686
Understanding the Spring MVC Project Structure �������������������������������������������������������� 686
Enabling Internationalization (i18n) ������������������������������������������������������������������������������ 687
Configuring i18n in the DispatcherServlet Configuration ������������������������������������������������������������������� 688
Modifying the Singer List View for i18n Support �������������������������������������������������������������������������������� 690
Using Theming and Templating ������������������������������������������������������������������������������������ 691
Theming Support �������������������������������������������������������������������������������������������������������������������������������� 691
View Templating with Apache Tiles ������������������������������������������������������������������������������ 693
Designing the Template Layout ���������������������������������������������������������������������������������������������������������� 693
Implementing Page Layout Components �������������������������������������������������������������������������������������������� 694
Configuring Tiles in Spring MVC ����������������������������������������������������������������������������������� 698
Implementing the Views for Singer Information ����������������������������������������������������������� 699
Mapping URLs to the Views ���������������������������������������������������������������������������������������������������������������� 699
Implementing the Show Singer View �������������������������������������������������������������������������������������������������� 700
■ Contents
xx
Implementing the Edit Singer View ���������������������������������������������������������������������������������������������������� 703
Implementing the Add Singer View ����������������������������������������������������������������������������������������������������� 708
Enabling JSR-349 (Bean Validation) ��������������������������������������������������������������������������������������������������� 709
Using jQuery and jQuery UI������������������������������������������������������������������������������������������� 711
Introducing jQuery and jQuery UI �������������������������������������������������������������������������������������������������������� 711
Enabling jQuery and jQuery UI in a View ��������������������������������������������������������������������������������������������� 712
Rich-Text Editing with CKEditor ���������������������������������������������������������������������������������������������������������� 714
Using jqGrid for a Data Grid with Pagination �������������������������������������������������������������������������������������� 715
Enabling jqGrid in the Singer List View ����������������������������������������������������������������������������������������������� 715
Enabling Pagination on the Server Side ��������������������������������������������������������������������������������������������� 717
Handling File Upload ���������������������������������������������������������������������������������������������������� 721
Configuring File Upload Support ��������������������������������������������������������������������������������������������������������� 721
Modifying Views for File Upload Support �������������������������������������������������������������������������������������������� 723
Modifying Controllers for File Upload Support ������������������������������������������������������������������������������������ 724
Securing a Web Application with Spring Security �������������������������������������������������������� 726
Configuring Spring Security ���������������������������������������������������������������������������������������������������������������� 726
Adding Login Functions to the Application ����������������������������������������������������������������������������������������� 729
Using Annotations to Secure Controller Methods ������������������������������������������������������������������������������� 731
Creating Spring Web Applications with Spring Boot ����������������������������������������������������� 732
Setting Up the DAO Layer ��������������������������������������������������������������������������������������������� 733
Setting Up the Service Layer �������������������������������������������������������������������������������������������������������������� 735
Setting Up the Web Layer ������������������������������������������������������������������������������������������������������������������� 735
Setting Up Spring Security ����������������������������������������������������������������������������������������������������������������� 737
Creating Thymeleaf Views �������������������������������������������������������������������������������������������� 738
Using Thymeleaf Extensions����������������������������������������������������������������������������������������� 743
Using Webjars ������������������������������������������������������������������������������������������������������������������������������������� 747
Summary ���������������������������������������������������������������������������������������������������������������������� 749
■Chapter 17: WebSocket ������������������������������������������������������������������������������������� 751
Introducing WebSocket ������������������������������������������������������������������������������������������������ 751
Using WebSocket with Spring �������������������������������������������������������������������������������������� 752
剩余865页未读,继续阅读
2018-07-27 上传
点击了解资源详情
2597 浏览量
2392 浏览量
hncsguy
- 粉丝: 0
- 资源: 2
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- Manning - Spring in Action (2007).pdf
- 食品类公司网站建设方案
- C# 日期函数 string.Format
- SAP财务成本知识库.pdf
- 很好的 学校网站方案
- 第11界全国青少年信息学奥林匹克联赛初赛试题(C语言)
- 协会学会网站建设方案
- 网上书店管理系统详细分析
- 软件需求分析 图形解释的
- S3C44B0X 中文数据手册
- 基于FLAASH的多光谱影像大气校正应用研究
- 基于J2EE的Ajax宝典.pdf
- 如何发表SCI论文,希望对大家有帮助!
- c# 提供面试题大全
- C++ Core 2000
- The MIT Press Essentials of Programming Languages 3rd Edition Apr 2008
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功