0
# Jetty Plus
1

2
JNDI support for Eclipse Jetty web server providing comprehensive enterprise Java features including dependency injection, lifecycle management, JNDI resource binding, and database-backed security services.
3

4
## Package Information
5

6
- **Package Name**: org.eclipse.jetty:jetty-plus
7
- **Language**: Java
8
- **Installation**: Maven: `<groupId>org.eclipse.jetty</groupId><artifactId>jetty-plus</artifactId><version>12.0.21</version>`
9

10
## Core Imports
11

12
```java
13
// Dependency injection and lifecycle management
14
import org.eclipse.jetty.plus.annotation.Injection;
15
import org.eclipse.jetty.plus.annotation.InjectionCollection;
16
import org.eclipse.jetty.plus.annotation.LifeCycleCallback;
17
import org.eclipse.jetty.plus.annotation.LifeCycleCallbackCollection;
18
import org.eclipse.jetty.plus.annotation.PostConstructCallback;
19
import org.eclipse.jetty.plus.annotation.PreDestroyCallback;
20

21
// JNDI resource binding
22
import org.eclipse.jetty.plus.jndi.NamingEntry;
23
import org.eclipse.jetty.plus.jndi.Resource;
24
import org.eclipse.jetty.plus.jndi.EnvEntry;
25
import org.eclipse.jetty.plus.jndi.Link;
26
import org.eclipse.jetty.plus.jndi.Transaction;
27
import org.eclipse.jetty.plus.jndi.DataSourceCloser;
28
import org.eclipse.jetty.plus.jndi.NamingEntryUtil;
29

30
// Database security
31
import org.eclipse.jetty.plus.security.DataSourceLoginService;
32
```
33

34
## Basic Usage
35

36
```java
37
import org.eclipse.jetty.plus.jndi.Resource;
38
import org.eclipse.jetty.plus.annotation.InjectionCollection;
39
import org.eclipse.jetty.plus.security.DataSourceLoginService;
40
import javax.sql.DataSource;
41

42
// 1. JNDI Resource Binding
43
// Bind a DataSource to JNDI for application use
44
DataSource dataSource = // ... your datasource configuration
45
Resource dsResource = new Resource("jdbc/MyDB", dataSource);
46

47
// 2. Dependency Injection Setup
48
// Configure injection collection for webapp
49
InjectionCollection injections = new InjectionCollection();
50
// Add to webapp context as attribute
51
context.setAttribute(InjectionCollection.INJECTION_COLLECTION, injections);
52

53
// 3. Database-backed Authentication
54
// Configure login service with database
55
DataSourceLoginService loginService = new DataSourceLoginService("MyRealm");
56
loginService.setJndiName("jdbc/MyDB");
57
loginService.setUserTableName("users");
58
loginService.setUserTableUserField("username");
59
loginService.setUserTablePasswordField("password");
60
loginService.setRoleTableName("roles");
61
server.addBean(loginService);
62
```
63

64
## Architecture
65

66
The jetty-plus module is organized into three main functional areas:
67

68
- **Annotation Support**: Handles JavaEE-style dependency injection and lifecycle callbacks (@PostConstruct, @PreDestroy)
69
- **JNDI Integration**: Provides comprehensive JNDI naming services for resource binding and lookup
70
- **Security Services**: Database-backed authentication and authorization through JNDI DataSources
71

72
This modular design allows applications to use only the features they need while maintaining full JEE compatibility for enterprise Java applications.
73

74
## Capabilities
75

76
### Dependency Injection and Lifecycle Management
77

78
Complete annotation-based dependency injection system with lifecycle callback support. Handles @Resource, @PostConstruct, and @PreDestroy annotations for enterprise Java applications.
79

80
```java { .api }
81
// Core injection functionality
82
class Injection {
83
    Injection(Class<?> clazz, Field field, Class<?> resourceType, String jndiName, String mappingName);
84
    Injection(Class<?> clazz, Method method, Class<?> arg, Class<?> resourceType, String jndiName, String mappingName);
85
    void inject(Object injectable);
86
    Object lookupInjectedValue() throws NamingException;
87
}
88

89
class InjectionCollection {
90
    void add(Injection injection);
91
    Set<Injection> getInjections(String className);
92
    void inject(Object injectable);
93
}
94

95
// Lifecycle management
96
class LifeCycleCallbackCollection {
97
    void add(LifeCycleCallback callback);
98
    void callPostConstructCallback(Object o) throws Exception;
99
    void callPreDestroyCallback(Object o) throws Exception;
100
}
101
```
102

103
[Dependency Injection and Lifecycle](./annotation-support.md)
104

105
### JNDI Resource Binding
106

107
Comprehensive JNDI naming and resource binding capabilities. Supports environment entries, resources, links, and transactions with full webapp context integration.
108

109
```java { .api }
110
// Core JNDI functionality
111
abstract class NamingEntry {
112
    void bindToENC(String localName) throws NamingException;
113
    void unbindENC();
114
    String getJndiName();
115
}
116

117
class Resource extends NamingEntry {
118
    Resource(Object scope, String jndiName, Object objToBind) throws NamingException;
119
    Resource(String jndiName, Object objToBind) throws NamingException;
120
}
121

122
class NamingEntryUtil {
123
    static boolean bindToENC(Object scope, String asName, String mappedName) throws NamingException;
124
    static Object lookup(Object scope, String jndiName) throws NamingException;
125
    static Context getContextForScope(Object scope) throws NamingException;
126
}
127
```
128

129
[JNDI Resource Binding](./jndi-integration.md)
130

131
### Database Security Services
132

133
Database-backed authentication and authorization using JNDI DataSources. Configurable user/role schema with full Jetty security integration.
134

135
```java { .api }
136
class DataSourceLoginService extends AbstractLoginService {
137
    DataSourceLoginService();
138
    DataSourceLoginService(String name);
139
    
140
    // Configuration
141
    void setJndiName(String jndi);
142
    void setUserTableName(String name);
143
    void setUserTableUserField(String tableUserField);
144
    void setUserTablePasswordField(String tablePasswordField);
145
    void setRoleTableName(String tableName);
146
    
147
    // Core authentication
148
    UserPrincipal loadUserInfo(String username);
149
    List<RolePrincipal> loadRoleInfo(UserPrincipal user);
150
}
151
```
152

153
[Database Security Services](./security-services.md)
154

155
## Dependencies
156

157
**Required Dependencies:**
158
- `org.eclipse.jetty:jetty-security` - Core Jetty security framework
159
- `org.eclipse.jetty:jetty-util` - Jetty utilities
160
- `org.slf4j:slf4j-api` - Logging framework
161

162
**Module Requirements:**
163
- `java.naming` - Java Naming and Directory Interface
164
- `java.sql` - SQL database connectivity (for DataSourceLoginService)
165

166
## Common Integration Patterns
167

168
### Webapp Context Configuration
169

170
```java
171
// Configure JNDI and injection for a webapp
172
WebAppContext webapp = new WebAppContext();
173

174
// Set up injection collection
175
InjectionCollection injections = new InjectionCollection();
176
webapp.setAttribute(InjectionCollection.INJECTION_COLLECTION, injections);
177

178
// Set up lifecycle callbacks
179
LifeCycleCallbackCollection callbacks = new LifeCycleCallbackCollection();
180
webapp.setAttribute(LifeCycleCallbackCollection.LIFECYCLE_CALLBACK_COLLECTION, callbacks);
181

182
// Bind JNDI resources
183
Resource dataSource = new Resource(webapp, "jdbc/MyDB", myDataSource);
184
EnvEntry maxConnections = new EnvEntry(webapp, "maxConnections", 100);
185
```
186

187
### Enterprise Application Setup
188

189
```java
190
// Complete enterprise setup combining all features
191
Server server = new Server();
192

193
// Database login service
194
DataSourceLoginService loginService = new DataSourceLoginService("MyRealm");
195
loginService.setJndiName("jdbc/SecurityDB");
196
loginService.setCreateTables(false);
197
server.addBean(loginService);
198

199
// Security handler with database authentication
200
SecurityHandler security = new SecurityHandler();
201
security.setLoginService(loginService);
202

203
// Webapp with JNDI and injection support
204
WebAppContext webapp = new WebAppContext();
205
webapp.setSecurityHandler(security);
206

207
// Configure JNDI resources
208
Resource securityDB = new Resource("jdbc/SecurityDB", createSecurityDataSource());
209
Resource appDB = new Resource("jdbc/AppDB", createApplicationDataSource());
210

211
// Transaction support
212
Transaction.bindTransactionToENC(webapp.toString());
213
```