|
1
45
46 package org.openejb.alt.assembler.classic;
47
48 import org.openejb.OpenEJBException;
49 import org.openejb.core.CoreUserTransaction;
50 import org.openejb.core.ivm.naming.IntraVmJndiReference;
51 import org.openejb.core.ivm.naming.IvmContext;
52 import org.openejb.core.ivm.naming.JndiReference;
53 import org.openejb.core.ivm.naming.NameNode;
54 import org.openejb.core.ivm.naming.ParsedName;
55 import org.openejb.core.ivm.naming.Reference;
56
57 import javax.naming.Context  ;
58 import javax.naming.NamingException ;
59 import javax.transaction.UserTransaction ;
60 import java.util.HashMap ;
61 import java.util.Iterator ;
62 import java.util.Map ;
63
64
67 public class JndiEncBuilder {
68
69 private final ReferenceWrapper referenceWrapper;
70 private final boolean beanManagedTransactions;
71 private final EjbReferenceInfo[] ejbReferences;
72 private final EjbLocalReferenceInfo[] ejbLocalReferences;
73 private final EnvEntryInfo[] envEntries;
74 private final ResourceReferenceInfo[] resourceRefs;
75
76
83 public JndiEncBuilder(JndiEncInfo jndiEnc, String transactionType, EjbType ejbType) throws OpenEJBException {
84 if (ejbType.isEntity()) {
85 referenceWrapper = new EntityRefereceWrapper();
86 } else if (ejbType == EjbType.STATEFUL) {
87 referenceWrapper = new StatefulRefereceWrapper();
88 } else if (ejbType == EjbType.STATELESS) {
89 referenceWrapper = new StatelessRefereceWrapper();
90 } else {
91 throw new org.openejb.OpenEJBException("Unknown component type");
92 }
93
94 beanManagedTransactions = transactionType != null && transactionType.equalsIgnoreCase("Bean");
95
96 ejbReferences = (jndiEnc != null && jndiEnc.ejbReferences != null) ? jndiEnc.ejbReferences : new EjbReferenceInfo[]{};
97 ejbLocalReferences = (jndiEnc != null && jndiEnc.ejbLocalReferences != null) ? jndiEnc.ejbLocalReferences : new EjbLocalReferenceInfo[]{};
98 envEntries = (jndiEnc != null && jndiEnc.envEntries != null) ? jndiEnc.envEntries : new EnvEntryInfo[]{};
99 resourceRefs = (jndiEnc != null && jndiEnc.resourceRefs != null) ? jndiEnc.resourceRefs : new ResourceReferenceInfo[]{};
100 }
101
102 public Context build() throws OpenEJBException {
103 HashMap bindings = new HashMap ();
104
105 if (beanManagedTransactions) {
106 Object userTransaction = referenceWrapper.wrap(new CoreUserTransaction());
107 bindings.put("java:comp/UserTransaction", userTransaction);
108 }
109
110 for (int i = 0; i < ejbReferences.length; i++) {
111 EjbReferenceInfo referenceInfo = ejbReferences[i];
112 EjbReferenceLocationInfo location = referenceInfo.location;
113
114 Reference reference = null;
115
116 if (!location.remote) {
117 String jndiName = "java:openejb/ejb/" + location.ejbDeploymentId;
118 reference = new IntraVmJndiReference(jndiName);
119 } else {
120 String openEjbSubContextName = "java:openejb/remote_jndi_contexts/" + location.jndiContextId;
121 reference = new JndiReference(openEjbSubContextName, location.remoteRefName);
122 }
123 bindings.put(normalize(referenceInfo.referenceName), wrapReference(reference));
124 }
125
126 for (int i = 0; i < ejbLocalReferences.length; i++) {
127 EjbLocalReferenceInfo referenceInfo = ejbLocalReferences[i];
128
129 EjbReferenceLocationInfo location = referenceInfo.location;
130 if (location != null && !location.remote) {
131 String jndiName = "java:openejb/ejb/" + location.ejbDeploymentId + "Local";
132 Reference reference = new IntraVmJndiReference(jndiName);
133 bindings.put(normalize(referenceInfo.referenceName), wrapReference(reference));
134 }
135 }
136
137 for (int i = 0; i < envEntries.length; i++) {
138 EnvEntryInfo entry = envEntries[i];
139 try {
140 Class type = Class.forName(entry.type.trim());
141 Object obj = null;
142 if (type == String .class)
143 obj = new String (entry.value);
144 else if (type == Double .class) {
145 obj = new Double (entry.value);
146 } else if (type == Integer .class) {
147 obj = new Integer (entry.value);
148 } else if (type == Long .class) {
149 obj = new Long (entry.value);
150 } else if (type == Float .class) {
151 obj = new Float (entry.value);
152 } else if (type == Short .class) {
153 obj = new Short (entry.value);
154 } else if (type == Boolean .class) {
155 obj = new Boolean (entry.value);
156 } else if (type == Byte .class) {
157 obj = new Byte (entry.value);
158 } else {
159 throw new IllegalArgumentException ("Invalid env-ref-type " + type);
160 }
161
162 bindings.put(normalize(entry.name), obj);
163 } catch (ClassNotFoundException e) {
164 throw new IllegalArgumentException ("Invalid environment entry type: " + entry.type.trim() + " for entry: " + entry.name);
165 } catch (NumberFormatException e) {
166 throw new IllegalArgumentException ("The env-entry-value for entry " + entry.name + " was not recognizable as type " + entry.type + ". Received Message: " + e.getLocalizedMessage());
167 }
168 }
169
170 for (int i = 0; i < resourceRefs.length; i++) {
171 ResourceReferenceInfo referenceInfo = resourceRefs[i];
172 Reference reference = null;
173
174 if (referenceInfo.resourceID != null) {
175 String jndiName = "java:openejb/connector/" + referenceInfo.resourceID;
176 reference = new IntraVmJndiReference(jndiName);
177 } else {
178 String openEjbSubContextName1 = "java:openejb/remote_jndi_contexts/" + referenceInfo.location.jndiContextId;
179 String jndiName2 = referenceInfo.location.remoteRefName;
180 reference = new JndiReference(openEjbSubContextName1, jndiName2);
181 }
182 bindings.put(normalize(referenceInfo.referenceName), wrapReference(reference));
183 }
184
185 IvmContext enc = new IvmContext(new NameNode(null, new ParsedName("comp"), null));
186
187 for (Iterator iterator = bindings.entrySet().iterator(); iterator.hasNext();) {
188 Map.Entry entry = (Map.Entry ) iterator.next();
189 String name = (String ) entry.getKey();
190 Object value = entry.getValue();
191 try {
192 enc.bind(name, value);
193 } catch (NamingException e) {
194 throw new org.openejb.SystemException("Unable to bind '" + name + "' into bean's enc.", e);
195 }
196 }
197 return enc;
198 }
199
200 private String normalize(String name) {
201 if (name.charAt(0) == '/')
202 name = name.substring(1);
203 if (!(name.startsWith("java:comp/env") || name.startsWith("comp/env"))) {
204 if (name.startsWith("env/"))
205 name = "comp/" + name;
206 else
207 name = "comp/env/" + name;
208 }
209 return name;
210 }
211
212 private Object wrapReference(Reference reference) {
213 return referenceWrapper.wrap(reference);
214 }
215
216 static abstract class ReferenceWrapper {
217 abstract Object wrap(Reference reference);
218
219 abstract Object wrap(UserTransaction reference);
220 }
221
222 static class EntityRefereceWrapper extends ReferenceWrapper {
223 public Object wrap(Reference reference) {
224 return new org.openejb.core.entity.EncReference(reference);
225 }
226
227 public Object wrap(UserTransaction userTransaction) {
228 throw new IllegalStateException ("Entity beans cannot have references to UserTransaction instance");
229 }
230 }
231
232 static class StatelessRefereceWrapper extends ReferenceWrapper {
233 public Object wrap(Reference reference) {
234 return new org.openejb.core.stateless.EncReference(reference);
235 }
236
237 public Object wrap(UserTransaction userTransaction) {
238 return new org.openejb.core.stateless.EncUserTransaction((CoreUserTransaction) userTransaction);
239 }
240 }
241
242 static class StatefulRefereceWrapper extends ReferenceWrapper {
243 public Object wrap(Reference reference) {
244 return new org.openejb.core.stateful.EncReference(reference);
245 }
246
247 public Object wrap(UserTransaction userTransaction) {
248 return new org.openejb.core.stateful.EncUserTransaction((CoreUserTransaction) userTransaction);
249 }
250 }
251 }
252 |
Popular Tags |
Java API By Example, From Geeks To Geeks.