:notoc:

= Overview of DeltaSpike Modules

:Notice: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at. http://www.apache.org/licenses/LICENSE-2.0 . Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR  CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

DeltaSpike consists of ready-to-use modules. These include a core module and a number of optional modules for providing additional enterprise functionality to your applications. An overview of each module is provided here and for more information see the linked individual module pages.

[cols="1,3a"]
|===
|<<core#,Core>> |  For fundamental and defining DeltaSpike API and utility classes
|<<bean-validation#,Bean Validation>> | For adding CDI support in Bean Validation, enabling creation of CDI aware `ConstraintValidator` methods that can use business objects (EJBs, ManagedBeans) to support validation needs
|<<container-control#,Container Control>> | For CDI container booting and shutdown and associated context lifecycle management
|<<data#,Data>> | For an enhanced JPA experience with declarative queries, reducing boilerplate to a minimum
|<<jpa#,JPA>> | For transactional context and scope
|<<jsf#,JSF>> | For CDI integration with JSF, with type-safe view config, multi-window handling, new scopes (WindowScoped, ViewScope, ViewAccessScoped, GroupedConversationScoped) and integration with DeltaSpike “core” messages and exception handling
|<<partial-bean#,Partial-Bean>> | For implementing a generic handler to replace manual implementations of interfaces (or abstract classes)
|<<scheduler#,Scheduler>> | For simple integration with Quartz v2 (default) or any other scheduler that supports cron-expressions for job-classes
|<<security#,Security>> | For intercept and security checking on method calls
|<<servlet#,Servlet>> | For integration with the Java Servlet API, enabling injection of common servlet objects and propagation of servlet events to the CDI event bus
|<<test-control#,Test-Control>> | For writing CDI-based tests easily
|===