1 /*
2 * JBoss, Home of Professional Open Source
3 * Copyright 2005, JBoss Inc., and individual contributors as indicated
4 * by the @authors tag. See the copyright.txt in the distribution for a
5 * full listing of individual contributors.
6 *
7 * This is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU Lesser General Public License as
9 * published by the Free Software Foundation; either version 2.1 of
10 * the License, or (at your option) any later version.
11 *
12 * This software is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this software; if not, write to the Free
19 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21 */
22 package org.jboss.verifier.strategy;
23
24 // $Id: EJBVerifier20.java 41248 2006-02-17 08:31:12Z starksm $
25
26 import org.jboss.logging.Logger;
27 import org.jboss.metadata.BeanMetaData;
28 import org.jboss.metadata.EntityMetaData;
29 import org.jboss.metadata.MessageDrivenMetaData;
30 import org.jboss.metadata.SessionMetaData;
31 import org.jboss.verifier.Section;
32
33 import java.lang.reflect.Method;
34 import java.util.Arrays;
35 import java.util.Iterator;
36
37 /**
38 * EJB 2.0 bean verifier.
39 *
40 * @author Juha Lindfors (jplindfo@helsinki.fi)
41 * @author Jay Walters (jwalters@computer.org)
42 * @author <a href="mailto:criege@riege.com">Christian Riege</a>
43 * @author Thomas.Diesler@jboss.org
44 *
45 * @version $Revision: 41248 $
46 * @since JDK 1.3
47 */
48 public class EJBVerifier20 extends AbstractEJB2xVerifier
49 {
50 private static Logger log = Logger.getLogger(EJBVerifier20.class);
51
52 /*
53 * Constructor
54 */
55 public EJBVerifier20(VerificationContext context)
56 {
57 super(context);
58 }
59
60 public String getMessageBundle()
61 {
62 return "EJB20Messages.properties";
63 }
64
65 /***********************************************************************
66 *
67 * IMPLEMENTS VERIFICATION STRATEGY INTERFACE
68 *
69 ************************************************************************/
70 public void checkSession(SessionMetaData session)
71 {
72 boolean localOrRemoteExists = false;
73 boolean verified = false;
74
75 if (!verifyBean(session))
76 return;
77
78 verified = verifySessionBean(session);
79
80 if (hasRemoteInterfaces(session))
81 {
82 // Check remote interfaces
83 localOrRemoteExists = true;
84 verified = verified && verifySessionRemote(session);
85 verified = verified && verifySessionHome(session);
86 }
87
88 if (hasLocalInterfaces(session))
89 {
90 // Check local interfaces
91 localOrRemoteExists = true;
92 verified = verified && verifySessionLocal(session);
93 verified = verified && verifySessionLocalHome(session);
94 }
95
96 // The session bean MUST implement either a remote home and
97 // remote, or local home and local interface. It MAY implement a
98 // remote home, remote, local home or local interface.
99 //
100 // Spec 7.10.1
101 //
102 if (!localOrRemoteExists)
103 {
104 fireSpecViolationEvent(session, new Section("7.10.1"));
105 verified = false;
106 }
107
108 if (verified)
109 {
110 // All OK; full steam ahead
111 fireBeanVerifiedEvent(session);
112 }
113 }
114
115 public void checkEntity(EntityMetaData entity)
116 {
117 if (entity.isCMP1x())
118 {
119 cmp1XVerifier.checkEntity(entity);
120 }
121 else
122 {
123 checkBmpOrCmp2Entity(entity);
124 }
125 }
126
127 public void checkMessageBean(MessageDrivenMetaData mdb)
128 {
129 boolean beanVerified = false;
130
131 if (!verifyBean(mdb))
132 return;
133
134 beanVerified = verifyMessageDrivenBean(mdb);
135
136 if (beanVerified)
137 {
138 // OK, we're done
139 fireBeanVerifiedEvent(mdb);
140 }
141 }
142
143 private void checkBmpOrCmp2Entity(EntityMetaData entity)
144 {
145 boolean localOrRemoteExists = false;
146 boolean verified = false;
147
148 if (!verifyBean(entity))
149 return;
150
151 if (entity.isCMP())
152 {
153 verified = verifyCMPEntityBean(entity);
154 }
155 else if (entity.isBMP())
156 {
157 verified = verifyBMPEntityBean(entity);
158 }
159
160 if (hasRemoteInterfaces(entity))
161 {
162 // Check remote interfaces
163 localOrRemoteExists = true;
164 verified = verified && verifyEntityRemote(entity);
165 verified = verified && verifyEntityHome(entity);
166 }
167
168 if (hasLocalInterfaces(entity))
169 {
170 // Check local interfaces
171 localOrRemoteExists = true;
172 verified = verified && verifyEntityLocal(entity);
173 verified = verified && verifyEntityLocalHome(entity);
174 }
175
176 verified = verified && verifyPrimaryKey(entity);
177
178 if (!localOrRemoteExists)
179 {
180 // The entity bean MUST implement either a remote home and
181 // remote, or local home and local interface. It MAY implement
182 // a remote home, remote, local home or local interface.
183 //
184 // Spec 10.6.1 (CMP) / 12.2.1 (BMP)
185 //
186 if (entity.isCMP())
187 {
188 fireSpecViolationEvent(entity, new Section("10.6.1"));
189 verified = false;
190 }
191 else
192 {
193 fireSpecViolationEvent(entity, new Section("12.2.1"));
194 verified = false;
195 }
196 }
197
198 if (verified)
199 {
200 fireBeanVerifiedEvent(entity);
201 }
202 }
203
204 /**
205 * Try to load the beans class declared in the <ejb-class>
206 * element.
207 *
208 * @return <code>true</code> if everything went alright
209 */
210 protected boolean verifyBean(BeanMetaData theBean)
211 {
212 String beanName = theBean.getEjbClass();
213
214 if (beanName == null)
215 return false;
216
217 try
218 {
219 bean = classloader.loadClass(beanName);
220 return true;
221 }
222 catch (ClassNotFoundException cnfe)
223 {
224 fireSpecViolationEvent(theBean, new Section("22.2.b",
225 "Class not found on '" + beanName + "': " + cnfe.getMessage()));
226 return false;
227 }
228 }
229
230 /**
231 * Check whether the bean has declared local interfaces and whether
232 * we can load the defined classes
233 *
234 * @return <code>true</code> if everything went alright
235 */
236 protected boolean hasRemoteInterfaces(BeanMetaData bean)
237 {
238 boolean status = true;
239 String homeName = bean.getHome();
240 String remoteName = bean.getRemote();
241
242 if (homeName == null || remoteName == null)
243 return false;
244
245 // Verify the <home> class
246 try
247 {
248 home = classloader.loadClass(homeName);
249 }
250 catch (ClassNotFoundException cnfe)
251 {
252 fireSpecViolationEvent(bean, new Section("22.2.c",
253 "Class not found on '" + homeName + "': " + cnfe.getMessage()));
254 status = false;
255 }
256
257 // Verify the <remote> class
258 try
259 {
260 remote = classloader.loadClass(remoteName);
261 }
262 catch (ClassNotFoundException cnfe)
263 {
264 fireSpecViolationEvent(bean, new Section("22.2.d",
265 "Class not found on '" + remoteName + "': " + cnfe.getMessage()));
266 status = false;
267 }
268
269 return status;
270 }
271
272 /**
273 * Check whether the bean has declared local interfaces and whether
274 * we can load the defined classes
275 *
276 * @return <code>true</code> if everything went alright
277 */
278 protected boolean hasLocalInterfaces(BeanMetaData bean)
279 {
280 boolean status = true;
281 String localHomeName = bean.getLocalHome();
282 String localName = bean.getLocal();
283
284 if (localHomeName == null || localName == null)
285 return false;
286
287 // Verify the <local-home> class
288 try
289 {
290 localHome = classloader.loadClass(localHomeName);
291 }
292 catch (ClassNotFoundException cnfe)
293 {
294 fireSpecViolationEvent(bean, new Section("22.2.e",
295 "Class not found on '" + localHomeName + "': " +
296 cnfe.getMessage()));
297 status = false;
298 }
299
300 try
301 {
302 local = classloader.loadClass(localName);
303 }
304 catch (ClassNotFoundException cnfe)
305 {
306 fireSpecViolationEvent(bean, new Section("22.2.f",
307 "Class not found on '" + localName + "': " + cnfe.getMessage()));
308 status = false;
309 }
310
311 return status;
312 }
313
314 /**
315 * Verifies the session bean remote home interface against the EJB 2.0
316 * specification.
317 *
318 * @param session XML metadata of the session bean
319 */
320 protected boolean verifySessionHome(SessionMetaData session)
321 {
322 boolean status = true;
323
324 // The home interface of a stateless session bean MUST have one
325 // create() method that takes no arguments.
326 //
327 // The create() method MUST return the session bean's remote
328 // interface.
329 //
330 // There CAN NOT be other create() methods in the home interface.
331 //
332 // Spec 7.10.6
333 //
334 if (session.isStateless())
335 {
336 if (!hasDefaultCreateMethod(home))
337 {
338 fireSpecViolationEvent(session, new Section("7.10.6.d2"));
339 status = false;
340 }
341 else
342 {
343 Method create = getDefaultCreateMethod(home);
344
345 if (hasMoreThanOneCreateMethods(home))
346 {
347 fireSpecViolationEvent(session, new Section("7.10.6.d2"));
348 status = false;
349 }
350 }
351 }
352
353 // The session bean's home interface MUST extend the
354 // javax.ejb.EJBHome interface.
355 //
356 // Spec 7.10.6
357 //
358 if (!hasEJBHomeInterface(home))
359 {
360 fireSpecViolationEvent(session, new Section("7.10.6.a"));
361 status = false;
362 }
363
364 // Method arguments defined in the home interface MUST be
365 // of valid types for RMI/IIOP.
366 //
367 // Method return values defined in the home interface MUST
368 // be of valid types for RMI/IIOP.
369 //
370 // Methods defined in the home interface MUST include
371 // java.rmi.RemoteException in their throws clause.
372 //
373 // Spec 7.10.6
374 ///
375 Iterator it = Arrays.asList(home.getMethods()).iterator();
376 while (it.hasNext())
377 {
378 Method method = (Method)it.next();
379
380 if (!hasLegalRMIIIOPArguments(method))
381 {
382 fireSpecViolationEvent(session, method, new Section("7.10.6.b1"));
383 status = false;
384 }
385
386 if (!hasLegalRMIIIOPReturnType(method))
387 {
388 fireSpecViolationEvent(session, method, new Section("7.10.6.b2"));
389 status = false;
390 }
391
392 if (!throwsRemoteException(method))
393 {
394 fireSpecViolationEvent(session, method, new Section("7.10.6.b3"));
395 status = false;
396 }
397 }
398
399 // A session bean's home interface MUST define one or more
400 // create(...) methods.
401 //
402 // Spec 7.10.6
403 //
404 if (!hasCreateMethod(home))
405 {
406 fireSpecViolationEvent(session, new Section("7.10.6.d1"));
407 status = false;
408 }
409
410 // Each create(...) method in the session bean's home interface
411 // MUST have a matching ejbCreate(...) method in the session
412 // bean's class.
413 //
414 // Each create(...) method in the session bean's home interface
415 // MUST have the same number and types of arguments to its
416 // matching ejbCreate(...) method.
417 //
418 // The return type for a create(...) method MUST be the session
419 // bean's remote interface type.
420 //
421 // All the exceptions defined in the throws clause of the matching
422 // ejbCreate(...) method of the enterprise bean class MUST be
423 // included in the throws clause of a matching create(...) method.
424 //
425 // The throws clause of a create(...) method MUST include the
426 // javax.ejb.CreateException.
427 //
428 // Spec 7.10.6
429 //
430 Iterator createMethods = getCreateMethods(home);
431 while (createMethods.hasNext())
432 {
433 Method create = (Method)createMethods.next();
434
435 if (!hasMatchingEJBCreate(bean, create))
436 {
437 fireSpecViolationEvent(session, create, new Section("7.10.6.e"));
438 status = false;
439 }
440
441 if (!hasRemoteReturnType(session, create))
442 {
443 fireSpecViolationEvent(session, create, new Section("7.10.6.f"));
444 status = false;
445 }
446
447 if (hasMatchingEJBCreate(bean, create))
448 {
449 Method ejbCreate = getMatchingEJBCreate(bean, create);
450 if (!hasMatchingExceptions(ejbCreate, create))
451 {
452 fireSpecViolationEvent(session, create,
453 new Section("7.10.6.g"));
454 status = false;
455 }
456 }
457
458 if (!throwsCreateException(create))
459 {
460 fireSpecViolationEvent(session, create, new Section("7.10.6.h"));
461 status = false;
462 }
463 }
464
465 return status;
466 }
467
468 /**
469 * Verifies the session bean local home interface against the EJB 2.0
470 * specification.
471 *
472 * @param session parsed metadata of the session bean
473 */
474 protected boolean verifySessionLocalHome(SessionMetaData session)
475 {
476 boolean status = true;
477
478 // The local home interface of a stateless session bean MUST have
479 // one create() method that takes no arguments.
480 //
481 // There CAN NOT be other create() methods in the home interface.
482 //
483 // Spec 7.10.8
484 //
485 if (session.isStateless())
486 {
487 if (!hasDefaultCreateMethod(localHome))
488 {
489 fireSpecViolationEvent(session, new Section("7.10.8.d2"));
490 status = false;
491 }
492 else
493 {
494 Method create = getDefaultCreateMethod(localHome);
495
496 if (hasMoreThanOneCreateMethods(localHome))
497 {
498 fireSpecViolationEvent(session, new Section("7.10.8.d2"));
499 status = false;
500 }
501 }
502 }
503
504 // The session bean's home interface MUST extend the
505 // javax.ejb.EJBLocalHome interface.
506 //
507 // Spec 7.10.8
508 //
509 if (!hasEJBLocalHomeInterface(localHome))
510 {
511 fireSpecViolationEvent(session, new Section("7.10.8.a"));
512 status = false;
513 }
514
515 // Methods defined in the local home interface MUST NOT include
516 // java.rmi.RemoteException in their throws clause.
517 //
518 // Spec 7.10.8
519 //
520 Iterator it = Arrays.asList(localHome.getMethods()).iterator();
521 while (it.hasNext())
522 {
523 Method method = (Method)it.next();
524
525 if (throwsRemoteException(method))
526 {
527 fireSpecViolationEvent(session, method, new Section("7.10.8.b"));
528 status = false;
529 }
530 }
531
532 // A session bean's home interface MUST define one or more
533 // create(...) methods.
534 //
535 // Spec 7.10.8
536 //
537 if (!hasCreateMethod(localHome))
538 {
539 fireSpecViolationEvent(session, new Section("7.10.8.d1"));
540 status = false;
541 }
542
543 // Each create(...) method in the session bean's local home
544 // interface MUST have a matching ejbCreate(...) method in the
545 // session bean's class.
546 //
547 // Each create(...) method in the session bean's home interface
548 // MUST have the same number and types of arguments to its
549 // matching ejbCreate(...) method.
550 //
551 // The return type for a create(...) method MUST be the session
552 // bean's local interface type.
553 //
554 // All the exceptions defined in the throws clause of the matching
555 // ejbCreate(...) method of the enterprise bean class MUST be
556 // included in the throws clause of a matching create(...) method.
557 //
558 // The throws clause of a create(...) method MUST include the
559 // javax.ejb.CreateException.
560 //
561 // Spec 7.10.8
562 //
563 Iterator createMethods = getCreateMethods(localHome);
564 while (createMethods.hasNext())
565 {
566 Method create = (Method)createMethods.next();
567
568 if (!hasMatchingEJBCreate(bean, create))
569 {
570 fireSpecViolationEvent(session, create,
571 new Section("7.10.8.e"));
572 status = false;
573 }
574
575 if (!hasLocalReturnType(session, create))
576 {
577 fireSpecViolationEvent(session, create,
578 new Section("7.10.8.f"));
579 status = false;
580 }
581
582 if (hasMatchingEJBCreate(bean, create))
583 {
584 Method ejbCreate = getMatchingEJBCreate(bean, create);
585 if (!hasMatchingExceptions(ejbCreate, create))
586 {
587 fireSpecViolationEvent(session, create,
588 new Section("7.10.8.g"));
589 }
590 }
591
592 if (!throwsCreateException(create))
593 {
594 fireSpecViolationEvent(session, create,
595 new Section("7.10.8.h"));
596 status = false;
597 }
598 }
599
600 return status;
601 }
602
603 /*
604 * Verify Session Bean Remote Interface
605 */
606 protected boolean verifySessionRemote(SessionMetaData session)
607 {
608 boolean status = true;
609
610 // The remote interface MUST extend the javax.ejb.EJBObject
611 // interface.
612 //
613 // Spec 7.10.5
614 //
615 if (!hasEJBObjectInterface(remote))
616 {
617 fireSpecViolationEvent(session, new Section("7.10.5.a"));
618 status = false;
619 }
620
621 // Method arguments defined in the remote interface MUST be
622 // of valid types for RMI/IIOP.
623 //
624 // Method return values defined in the remote interface MUST
625 // be of valid types for RMI/IIOP.
626 //
627 // Methods defined in the remote interface MUST include
628 // java.rmi.RemoteException in their throws clause.
629 //
630 // Spec 7.10.5
631 //
632 Iterator it = Arrays.asList(remote.getMethods()).iterator();
633 while (it.hasNext())
634 {
635 Method method = (Method)it.next();
636
637 if (!hasLegalRMIIIOPArguments(method))
638 {
639 fireSpecViolationEvent(session, method, new Section("7.10.5.b1"));
640 status = false;
641 }
642
643 if (!hasLegalRMIIIOPReturnType(method))
644 {
645 fireSpecViolationEvent(session, method, new Section("7.10.5.b2"));
646 status = false;
647 }
648
649 if (!throwsRemoteException(method))
650 {
651 fireSpecViolationEvent(session, method, new Section("7.10.5.b3"));
652 status = false;
653 }
654 }
655
656 // For each method defined in the remote interface, there MUST be
657 // a matching method in the session bean's class. The matching
658 // method MUST have:
659 //
660 // - the same name
661 // - the same number and types of arguments, and the same
662 // return type
663 // - All the exceptions defined in the throws clause of the
664 // matching method of the session bean class must be defined
665 // in the throws clause of the method of the remote interface
666 //
667 // Spec 7.10.5
668 //
669 it = Arrays.asList(remote.getDeclaredMethods()).iterator();
670 while (it.hasNext())
671 {
672 Method remoteMethod = (Method)it.next();
673
674 if (!hasMatchingMethod(bean, remoteMethod))
675 {
676 fireSpecViolationEvent(session, remoteMethod,
677 new Section("7.10.5.d1"));
678
679 status = false;
680 }
681
682 if (hasMatchingMethod(bean, remoteMethod))
683 {
684 try
685 {
686 Method beanMethod = bean.getMethod(remoteMethod.getName(),
687 remoteMethod.getParameterTypes());
688
689 if (!hasMatchingReturnType(remoteMethod, beanMethod))
690 {
691 fireSpecViolationEvent(session, remoteMethod,
692 new Section("7.10.5.d2"));
693 status = false;
694 }
695
696 if (!hasMatchingExceptions(beanMethod, remoteMethod))
697 {
698 fireSpecViolationEvent(session, remoteMethod,
699 new Section("7.10.5.d3"));
700 status = false;
701 }
702 }
703 catch (NoSuchMethodException ignored)
704 {
705 }
706 }
707 }
708
709 return status;
710 }
711
712 /*
713 * Verify Session Bean Local Interface
714 */
715 protected boolean verifySessionLocal(SessionMetaData session)
716 {
717 boolean status = true;
718
719 // The local interface MUST extend the javax.ejb.EJBLocalObject
720 // interface.
721 //
722 // Spec 7.10.7
723 //
724 if (!hasEJBLocalObjectInterface(local))
725 {
726 fireSpecViolationEvent(session, new Section("7.10.7.a"));
727 status = false;
728 }
729
730 // Methods defined in the local interface MUST NOT include
731 // java.rmi.RemoteException in their throws clause.
732 //
733 // Spec 7.10.7
734 //
735 Iterator it = Arrays.asList(local.getMethods()).iterator();
736 while (it.hasNext())
737 {
738 Method method = (Method)it.next();
739 if (throwsRemoteException(method))
740 {
741 fireSpecViolationEvent(session, method, new Section("7.10.7.b"));
742 status = false;
743 }
744 }
745
746 // For each method defined in the local interface, there MUST be
747 // a matching method in the session bean's class. The matching
748 // method MUST have:
749 //
750 // - the same name
751 // - the same number and types of arguments, and the same
752 // return type
753 // - All the exceptions defined in the throws clause of the
754 // matching method of the session bean class must be defined
755 // in the throws clause of the method of the remote interface
756 //
757 // Spec 7.10.7
758 //
759 it = Arrays.asList(local.getDeclaredMethods()).iterator();
760 while (it.hasNext())
761 {
762 Method localMethod = (Method)it.next();
763
764 if (!hasMatchingMethod(bean, localMethod))
765 {
766 fireSpecViolationEvent(session, localMethod,
767 new Section("7.10.7.d1"));
768 status = false;
769 }
770
771 if (hasMatchingMethod(bean, localMethod))
772 {
773 try
774 {
775 Method beanMethod = bean.getMethod(localMethod.getName(),
776 localMethod.getParameterTypes());
777
778 if (!hasMatchingReturnType(localMethod, beanMethod))
779 {
780 fireSpecViolationEvent(session, localMethod,
781 new Section("7.10.7.d2"));
782 status = false;
783 }
784
785 if (!hasMatchingExceptions(beanMethod, localMethod))
786 {
787 fireSpecViolationEvent(session, localMethod,
788 new Section("7.10.7.d3"));
789 status = false;
790 }
791 }
792 catch (NoSuchMethodException ignored)
793 {
794 }
795 }
796 }
797
798 return status;
799 }
800
801 /*
802 * Verify Session Bean
803 */
804 protected boolean verifySessionBean(SessionMetaData session)
805 {
806 boolean status = true;
807
808 // A session bean MUST implement, directly or indirectly,
809 // javax.ejb.SessionBean interface.
810 //
811 // Spec 7.10.2
812 //
813 if (!hasSessionBeanInterface(bean))
814 {
815 fireSpecViolationEvent(session, new Section("7.10.2.a"));
816 status = false;
817 }
818
819 // Only a stateful container-managed transaction demarcation
820 // session bean MAY implement the SessionSynchronization
821 // interface.
822 //
823 // A stateless Session bean MUST NOT implement the
824 // SessionSynchronization interface.
825 //
826 // Spec 7.5.3
827 //
828 if (hasSessionSynchronizationInterface(bean))
829 {
830 if (session.isStateless())
831 {
832 fireSpecViolationEvent(session, new Section("7.5.3.a"));
833 status = false;
834 }
835
836 if (session.isBeanManagedTx())
837 {
838 fireSpecViolationEvent(session, new Section("7.5.3.b"));
839 status = false;
840 }
841 }
842
843 //
844 // A session bean MUST implement AT LEAST one ejbCreate method.
845 //
846 // Spec 7.10.3
847 //
848 if (!hasEJBCreateMethod(bean, true))
849 {
850 fireSpecViolationEvent(session, new Section("7.10.3"));
851 status = false;
852 }
853
854 // A session with bean-managed transaction demarcation CANNOT
855 // implement the SessionSynchronization interface.
856 //
857 // Spec 7.6.1 (table 2)
858 //
859 if (hasSessionSynchronizationInterface(bean)
860 && session.isBeanManagedTx())
861 {
862 fireSpecViolationEvent(session, new Section("7.6.1"));
863 status = false;
864 }
865
866 // The session bean class MUST be defined as public.
867 //
868 // Spec 7.10.2
869 //
870 if (!isPublic(bean))
871 {
872 fireSpecViolationEvent(session, new Section("7.10.2.b1"));
873 status = false;
874 }
875
876 // The session bean class MUST NOT be final.
877 //
878 // Spec 7.10.2
879 //
880 if (isFinal(bean))
881 {
882 fireSpecViolationEvent(session, new Section("7.10.2.b2"));
883 status = false;
884 }
885
886 // The session bean class MUST NOT be abstract.
887 //
888 // Spec 7.10.2
889 //
890 if (isAbstract(bean))
891 {
892 fireSpecViolationEvent(session, new Section("7.10.2.b3"));
893 status = false;
894 }
895
896 // The session bean class MUST have a public constructor that
897 // takes no arguments.
898 //
899 // Spec 7.10.2
900 //
901 if (!hasDefaultConstructor(bean))
902 {
903 fireSpecViolationEvent(session, new Section("7.10.2.c"));
904 status = false;
905 }
906
907 // The session bean class MUST NOT define the finalize() method.
908 //
909 // Spec 7.10.2
910 //
911 if (hasFinalizer(bean))
912 {
913 fireSpecViolationEvent(session, new Section("7.10.2.d"));
914 status = false;
915 }
916
917 // The ejbCreate(...) method signatures MUST follow these rules:
918 //
919 // - The method name MUST have ejbCreate as its prefix
920 // - The method MUST be declared as public
921 // - The method MUST NOT be declared as final or static
922 // - The return type MUST be void
923 // - The method arguments MUST be legal types for RMI/IIOP
924 // - The method SHOULD not throw a java.rmi.RemoteException
925 // (NOTE we don't test for this as it's not a MUST)
926 //
927 // Spec 7.10.3
928 //
929 if (hasEJBCreateMethod(bean, true))
930 {
931 Iterator it = getEJBCreateMethods(bean);
932 while (it.hasNext())
933 {
934 Method ejbCreate = (Method)it.next();
935
936 if (!isPublic(ejbCreate))
937 {
938 fireSpecViolationEvent(session, ejbCreate,
939 new Section("7.10.3.b"));
940 status = false;
941 }
942
943 if ((isFinal(ejbCreate)) || (isStatic(ejbCreate)))
944 {
945 fireSpecViolationEvent(session, ejbCreate,
946 new Section("7.10.3.c"));
947 status = false;
948 }
949
950 if (!hasVoidReturnType(ejbCreate))
951 {
952 fireSpecViolationEvent(session, ejbCreate,
953 new Section("7.10.3.d"));
954 status = false;
955 }
956
957 if (!hasLegalRMIIIOPArguments(ejbCreate))
958 {
959 fireSpecViolationEvent(session, ejbCreate,
960 new Section("7.10.3.e"));
961 status = false;
962 }
963 }
964 }
965
966 return status;
967 }
968
969 /*
970 * Verify Entity Bean Home Interface
971 */
972 private boolean verifyEntityHome(EntityMetaData entity)
973 {
974 boolean status = true;
975
976 // Entity bean's home interface MUST extend the javax.ejb.EJBHome
977 // interface.
978 //
979 // Spec 12.2.9
980 //
981 if (!hasEJBHomeInterface(home))
982 {
983 fireSpecViolationEvent(entity, new Section("12.2.9.a"));
984 status = false;
985 }
986
987 // The methods defined in the entity bean's home interface MUST
988 // have valid RMI-IIOP argument types.
989 //
990 // The methods defined in the entity bean's home interface MUST
991 // have valid RMI-IIOP return types.
992 //
993 // The methods defined in the entity bean's home interface MUST
994 // have java.rmi.RemoteException in their throws clause.
995 //
996 // Spec 12.2.9
997 //
998 Iterator methods = Arrays.asList(home.getMethods()).iterator();
999 while (methods.hasNext())
1000 {
1001 Method method = (Method)methods.next();
1002
1003 if (!hasLegalRMIIIOPArguments(method))
1004 {
1005 fireSpecViolationEvent(entity, method,
1006 new Section("12.2.9.b1"));
1007 status = false;
1008 }
1009
1010 if (!hasLegalRMIIIOPReturnType(method))
1011 {
1012 fireSpecViolationEvent(entity, method,
1013 new Section("12.2.9.b2"));
1014 status = false;
1015 }
1016
1017 if (!throwsRemoteException(method))
1018 {
1019 fireSpecViolationEvent(entity, method,
1020 new Section("12.2.9.b3"));
1021 status = false;
1022 }
1023 }
1024
1025 // Each method defined in the entity bean's home interface must be
1026 // one of the following:
1027 //
1028 // - a create method
1029 // - a finder method
1030 // - a home method
1031 //
1032 // Spec 12.2.9
1033 //
1034 methods = Arrays.asList(home.getMethods()).iterator();
1035 while (methods.hasNext())
1036 {
1037 Method method = (Method)methods.next();
1038
1039 // Do not check the methods of the javax.ejb.EJBHome interface
1040 if (method.getDeclaringClass().getName().equals(EJB_HOME_INTERFACE))
1041 continue;
1042
1043 if (isCreateMethod(method))
1044 {
1045 // Each create(...) method in the entity bean's home
1046 // interface MUST have a matching ejbCreate(...) method in
1047 // the entity bean's class.
1048 //
1049 // Each create(...) method in the entity bean's home
1050 // interface MUST have the same number and types of
1051 // arguments to its matching ejbCreate(...) method.
1052 //
1053 // The return type for a create(...) method MUST be the
1054 // entity bean's remote interface type.
1055 //
1056 // All the exceptions defined in the throws clause of the
1057 // matching ejbCreate(...) and ejbPostCreate(...) methods of
1058 // the enterprise bean class MUST be included in the throws
1059 // clause of a matching create(...) method.
1060 //
1061 // The throws clause of a create(...) method MUST include
1062 // the javax.ejb.CreateException.
1063 //
1064 // Spec 12.2.9
1065 //
1066 if (!hasMatchingEJBCreate(bean, method))
1067 {
1068 fireSpecViolationEvent(entity, method, new Section("12.2.9.d"));
1069 status = false;
1070 }
1071
1072 if (!hasRemoteReturnType(entity, method))
1073 {
1074 fireSpecViolationEvent(entity, method, new Section("12.2.9.e"));
1075 status = false;
1076 }
1077
1078 if (hasMatchingEJBCreate(bean, method)
1079 && hasMatchingEJBPostCreate(bean, method))
1080 {
1081 Method ejbCreate = getMatchingEJBCreate(bean, method);
1082 Method ejbPostCreate = getMatchingEJBPostCreate(bean, method);
1083
1084 if (!(hasMatchingExceptions(ejbCreate, method)
1085 && hasMatchingExceptions(ejbPostCreate, method)))
1086 {
1087 fireSpecViolationEvent(entity, method,
1088 new Section("12.2.9.f"));
1089 }
1090 }
1091
1092 if (!throwsCreateException(method))
1093 {
1094 fireSpecViolationEvent(entity, method, new Section("12.2.9.g"));
1095 status = false;
1096 }
1097 }
1098 else if (isFinderMethod(method))
1099 {
1100 // Each finder method MUST match one of the ejbFind<METHOD>
1101 // methods defined in the entity bean class.
1102 //
1103 // The matching ejbFind<METHOD> method MUST have the same
1104 // number and types of arguments.
1105 //
1106 // The return type for a find<METHOD> method MUST be the
1107 // entity bean's remote interface type (single-object
1108 // finder) or a collection thereof (for a multi-object
1109 // finder).
1110 //
1111 // All the exceptions defined in the throws clause of an
1112 // ejbFind method of the entity bean class MUST be included
1113 // in the throws clause of the matching find method of the
1114 // home interface.
1115 //
1116 // The throws clause of a finder method MUST include the
1117 // javax.ejb.FinderException.
1118 //
1119 // Spec 12.2.9
1120 //
1121 if (entity.isBMP())
1122 { // Check for BMP violations
1123 if ((!hasMatchingEJBFind(bean, method)))
1124 {
1125 fireSpecViolationEvent(entity, method,
1126 new Section("12.2.9.h"));
1127 status = false;
1128 }
1129
1130 if (!(hasRemoteReturnType(entity, method)
1131 || isMultiObjectFinder(method)))
1132 {
1133 fireSpecViolationEvent(entity, method,
1134 new Section("12.2.9.j"));
1135 status = false;
1136 }
1137
1138 if ((hasMatchingEJBFind(bean, method)))
1139 {
1140 Method ejbFind = getMatchingEJBFind(bean, method);
1141 if (!(hasMatchingExceptions(ejbFind, method)))
1142 {
1143 fireSpecViolationEvent(entity, method,
1144 new Section("12.2.9.k"));
1145 status = false;
1146 }
1147 }
1148
1149 if (!throwsFinderException(method))
1150 {
1151 fireSpecViolationEvent(entity, method,
1152 new Section("12.2.9.l"));
1153 status = false;
1154 }
1155 } // if( entity.isBMP() )
1156
1157 if (entity.isCMP())
1158 {
1159
1160 if (!(hasRemoteReturnType(entity, method)
1161 || isMultiObjectFinder(method)))
1162 {
1163 fireSpecViolationEvent(entity, method,
1164 new Section("10.6.10.a"));
1165 status = false;
1166 }
1167
1168 if (!throwsFinderException(method))
1169 {
1170 fireSpecViolationEvent(entity, method,
1171 new Section("10.6.10.b"));
1172 status = false;
1173 }
1174
1175 // For every finder method there must be a matching
1176 // <query> element defined in the deployment descriptor
1177 // with the exception of findByPrimaryKey
1178 //
1179 // JBoss Extension: 'findAll' is _also_ ignored.
1180 //
1181 if (!method.getName().equals("findByPrimaryKey")
1182 && !method.getName().equals("findAll")
1183 && !hasMatchingQuery(method, entity))
1184 {
1185 fireSpecViolationEvent(entity, method,
1186 new Section("10.5.6"));
1187 status = false;
1188 }
1189 } // if( entity.isCMP() )
1190 }
1191 else // Neither Create nor Finder method
1192 {
1193 // Each home method MUST match a method defined in the
1194 // entity bean class.
1195 //
1196 // The matching ejbHome<METHOD> method MUST have the same
1197 // number and types of arguments, and a matching return
1198 // type.
1199 //
1200 // Spec 12.2.9
1201 //
1202 if (!hasMatchingEJBHome(bean, method))
1203 {
1204 fireSpecViolationEvent(entity, method,
1205 new Section("12.2.9.m"));
1206 status = false;
1207 }
1208 }
1209 } // while( methods.hasNext() )
1210
1211
1212 return status;
1213 }
1214
1215 /*
1216 * Verify Entity Bean Local Home Interface
1217 */
1218 private boolean verifyEntityLocalHome(EntityMetaData entity)
1219 {
1220 boolean status = true;
1221
1222 // Entity bean's local home interface MUST extend the
1223 // javax.ejb.EJBLocalHome interface.
1224 //
1225 // Spec 12.2.11
1226 //
1227 if (!hasEJBLocalHomeInterface(localHome))
1228 {
1229 fireSpecViolationEvent(entity, new Section("12.2.11.a"));
1230 status = false;
1231 }
1232
1233 // The methods defined in the entity bean's home interface MUST
1234 // NOT have java.rmi.RemoteException in their throws clause.
1235 //
1236 // Spec 12.2.11
1237 //
1238 Iterator homeMethods = Arrays.asList(localHome.getMethods()).iterator();
1239 while (homeMethods.hasNext())
1240 {
1241 Method method = (Method)homeMethods.next();
1242
1243 if (throwsRemoteException(method))
1244 {
1245 fireSpecViolationEvent(entity, method, new Section("12.2.11.b"));
1246 status = false;
1247 }
1248 }
1249
1250 // Each method defined in the entity bean's local home interface
1251 // must be one of the following:
1252 //
1253 // - a create method
1254 // - a finder method
1255 // - a home method
1256 //
1257 // Spec 12.2.11
1258 //
1259 homeMethods = Arrays.asList(localHome.getMethods()).iterator();
1260 while (homeMethods.hasNext())
1261 {
1262 Method method = (Method)homeMethods.next();
1263
1264 // Do not check the methods of the javax.ejb.EJBLocalHome interface
1265 if (method.getDeclaringClass().getName().equals(EJB_LOCAL_HOME_INTERFACE))
1266 continue;
1267
1268 if (isCreateMethod(method))
1269 {
1270 // Each create(...) method in the entity bean's local home
1271 // interface MUST have a matching ejbCreate(...) method in
1272 // the entity bean's class.
1273 //
1274 // Each create(...) method in the entity bean's local home
1275 // interface MUST have the same number and types of
1276 // arguments to its matching ejbCreate(...) method.
1277 //
1278 // The return type for a create(...) method MUST be the
1279 // entity bean's local interface type.
1280 //
1281 // All the exceptions defined in the throws clause of the
1282 // matching ejbCreate(...) and ejbPostCreate(...) methods of
1283 // the enterprise bean class MUST be included in the throws
1284 // clause of a matching create(...) method.
1285 //
1286 // The throws clause of a create(...) method MUST include
1287 // the javax.ejb.CreateException.
1288 //
1289 // Spec 12.2.11
1290 //
1291 if (!hasMatchingEJBCreate(bean, method))
1292 {
1293 fireSpecViolationEvent(entity, method,
1294 new Section("12.2.11.e"));
1295 status = false;
1296 }
1297
1298 if (!hasLocalReturnType(entity, method))
1299 {
1300 fireSpecViolationEvent(entity, method,
1301 new Section("12.2.11.f"));
1302 status = false;
1303 }
1304
1305 if (hasMatchingEJBCreate(bean, method)
1306 && hasMatchingEJBPostCreate(bean, method))
1307 {
1308 Method ejbCreate = getMatchingEJBCreate(bean, method);
1309 Method ejbPostCreate = getMatchingEJBPostCreate(bean, method);
1310
1311 if (!(hasMatchingExceptions(ejbCreate, method)
1312 && hasMatchingExceptions(ejbPostCreate, method)))
1313 {
1314 fireSpecViolationEvent(entity, method,
1315 new Section("12.2.11.g"));
1316 }
1317 }
1318
1319 if (!throwsCreateException(method))
1320 {
1321 fireSpecViolationEvent(entity, method,
1322 new Section("12.2.11.h"));
1323 status = false;
1324 }
1325 }
1326 else if (isFinderMethod(method))
1327 {
1328 // Each finder method MUST match one of the ejbFind<METHOD>
1329 // methods defined in the entity bean class.
1330 //
1331 // The matching ejbFind<METHOD> method MUST have the same
1332 // number and types of arguments.
1333 //
1334 // The return type for a find<METHOD> method MUST be the
1335 // entity bean's local interface type (single-object finder)
1336 // or a collection thereof (for a multi-object finder).
1337 //
1338 // All the exceptions defined in the throws clause of an
1339 // ejbFind method of the entity bean class MUST be included
1340 // in the throws clause of the matching find method of the
1341 // home interface.
1342 //
1343 // The throws clause of a finder method MUST include the
1344 // javax.ejb.FinderException.
1345 //
1346 // Spec 12.2.11
1347 //
1348 if (!(hasLocalReturnType(entity, method)
1349 || isMultiObjectFinder(method)))
1350 {
1351 fireSpecViolationEvent(entity, method,
1352 new Section("12.2.11.j"));
1353 status = false;
1354 }
1355
1356 if (!throwsFinderException(method))
1357 {
1358 fireSpecViolationEvent(entity, method,
1359 new Section("12.2.11.k"));
1360 status = false;
1361 }
1362
1363 if (entity.isCMP())
1364 {
1365 // The entity bean class does not implement the finder
1366 // methods. The implementation of the finder methods are
1367 // provided by the Container
1368 //
1369 // Spec 10.6.2
1370 //
1371 if (hasMatchingEJBFind(bean, method))
1372 {
1373 fireSpecViolationEvent(entity, method,
1374 new Section("10.6.2.j"));
1375 status = false;
1376 }
1377
1378 // For every finder method there must be a matching
1379 // <query> element defined in the deployment descriptor
1380 // with the exception of findByPrimaryKey
1381 //
1382 // JBoss Extension: 'findAll' is _also_ ignored.
1383 //
1384 // Spec 10.5.6
1385 //
1386 if (!method.getName().equals("findByPrimaryKey")
1387 && !method.getName().equals("findAll")
1388 && !hasMatchingQuery(method, entity))
1389 {
1390 fireSpecViolationEvent(entity, method,
1391 new Section("10.5.6"));
1392 status = false;
1393 }
1394 }
1395
1396 if (entity.isBMP())
1397 {
1398 if (!hasMatchingEJBFind(bean, method))
1399 {
1400 fireSpecViolationEvent(entity, method,
1401 new Section("12.2.11.i"));
1402 status = false;
1403 }
1404 else
1405 {
1406 Method ejbFind = getMatchingEJBFind(bean, method);
1407
1408 if (!(hasMatchingExceptions(ejbFind, method)))
1409 {
1410 fireSpecViolationEvent(entity, method,
1411 new Section("12.2.11.l"));
1412 }
1413 }
1414 }
1415 }
1416 else
1417 {
1418 // Each home method MUST match a method defined in the
1419 // entity bean class.
1420 //
1421 // The matching ejbHome<METHOD> method MUST have the same
1422 // number and types of arguments, and a matching return
1423 // type.
1424 //
1425 // Spec 12.2.9
1426 //
1427 if (!hasMatchingEJBHome(bean, method))
1428 {
1429 fireSpecViolationEvent(entity, method,
1430 new Section("12.2.11.m"));
1431 status = false;
1432 }
1433 }
1434 } // while( homeMethods.hasNext() )
1435
1436 return status;
1437 }
1438
1439 /*
1440 * Verify Entity Bean Local Interface
1441 */
1442 private boolean verifyEntityLocal(EntityMetaData entity)
1443 {
1444 boolean status = true;
1445
1446 // Entity bean's local interface MUST extend
1447 // the javax.ejb.EJBLocalObject interface.
1448 //
1449 // Spec 12.2.10
1450 //
1451 if (!hasEJBLocalObjectInterface(local))
1452 {
1453 fireSpecViolationEvent(entity, new Section("12.2.10.a"));
1454 status = false;
1455 }
1456
1457 // The methods defined in the entity bean's local interface MUST
1458 // NOT have java.rmi.RemoteException in their throws clause.
1459 //
1460 // Spec 12.2.10
1461 //
1462 Iterator localMethods = Arrays.asList(local.getMethods()).iterator();
1463 while (localMethods.hasNext())
1464 {
1465 Method method = (Method)localMethods.next();
1466
1467 if (throwsRemoteException(method))
1468 {
1469 fireSpecViolationEvent(entity, method, new Section("12.2.10.b"));
1470 status = false;
1471 }
1472 }
1473
1474 // For each method defined in the local interface, there MUST be
1475 // a matching method in the entity bean's class. The matching
1476 // method MUST have:
1477 //
1478 // - The same name.
1479 // - The same number and types of its arguments.
1480 // - The same return type.
1481 // - All the exceptions defined in the throws clause of the
1482 // matching method of the enterprise Bean class must be
1483 // defined in the throws clause of the method of the local
1484 // interface.
1485 //
1486 // Spec 12.2.10
1487 //
1488 localMethods = Arrays.asList(local.getMethods()).iterator();
1489 while (localMethods.hasNext())
1490 {
1491 Method method = (Method)localMethods.next();
1492
1493 // Do not check the methods of the javax.ejb.EJBLocalObject
1494 // interface
1495 if (method.getDeclaringClass().getName().equals(EJB_LOCAL_OBJECT_INTERFACE))
1496 continue;
1497
1498 if (!hasMatchingMethod(bean, method))
1499 {
1500 fireSpecViolationEvent(entity, method, new Section("12.2.10.c"));
1501 status = false;
1502 }
1503
1504 if (hasMatchingMethod(bean, method))
1505 {
1506 try
1507 {
1508 Method beanMethod = bean.getMethod(method.getName(),
1509 method.getParameterTypes());
1510
1511 if (!hasMatchingReturnType(beanMethod, method))
1512 {
1513 fireSpecViolationEvent(entity, method,
1514 new Section("12.2.10.d"));
1515 status = false;
1516 }
1517
1518 if (!hasMatchingExceptions(beanMethod, method))
1519 {
1520 fireSpecViolationEvent(entity, method,
1521 new Section("12.2.10.e"));
1522
1523 status = false;
1524 }
1525 }
1526 catch (NoSuchMethodException ignored)
1527 {
1528 }
1529 }
1530 }
1531
1532 return status;
1533 }
1534
1535 /*
1536 * Verify Entity Bean Remote Interface
1537 */
1538 private boolean verifyEntityRemote(EntityMetaData entity)
1539 {
1540 boolean status = true;
1541
1542 // Entity bean's remote interface MUST extend
1543 // the javax.ejb.EJBObject interface.
1544 //
1545 // Spec 9.2.7
1546 //
1547 if (!hasEJBObjectInterface(remote))
1548 {
1549 fireSpecViolationEvent(entity, new Section("9.2.7.a"));
1550 status = false;
1551 }
1552
1553 // The methods defined in the entity bean's remote interface MUST
1554 // have valid RMI-IIOP argument types.
1555 //
1556 // The methods defined in the entity bean's home interface MUST
1557 // have valid RMI-IIOP return types.
1558 //
1559 // The methods defined in the entity bean's home interface MUST
1560 // have java.rmi.RemoteException in their throws clause.
1561 //
1562 // Spec 9.2.7
1563 //
1564 Iterator it = Arrays.asList(remote.getMethods()).iterator();
1565 while (it.hasNext())
1566 {
1567 Method method = (Method)it.next();
1568
1569 if (!hasLegalRMIIIOPArguments(method))
1570 {
1571 fireSpecViolationEvent(entity, method, new Section("9.2.7.b"));
1572 status = false;
1573 }
1574
1575 if (!hasLegalRMIIIOPReturnType(method))
1576 {
1577 fireSpecViolationEvent(entity, method, new Section("9.2.7.c"));
1578 status = false;
1579 }
1580
1581 if (!hasLegalRMIIIOPExceptionTypes(method))
1582 {
1583 fireSpecViolationEvent(entity, method, new Section("9.2.7.h"));
1584 status = false;
1585 }
1586
1587 if (!throwsRemoteException(method))
1588 {
1589 fireSpecViolationEvent(entity, method, new Section("9.2.7.d"));
1590 status = false;
1591 }
1592 }
1593
1594 // For each method defined in the remote interface, there MUST be
1595 // a matching method in the entity bean's class. The matching
1596 // method MUST have:
1597 //
1598 // - The same name.
1599 // - The same number and types of its arguments.
1600 // - The same return type.
1601 // - All the exceptions defined in the throws clause of the
1602 // matching method of the enterprise Bean class must be
1603 // defined in the throws clause of the method of the remote
1604 // interface.
1605 //
1606 // Spec 9.2.7
1607 //
1608 it = Arrays.asList(remote.getMethods()).iterator();
1609 while (it.hasNext())
1610 {
1611 Method method = (Method)it.next();
1612
1613 // Do not check the methods of the javax.ejb.EJBObject interface
1614 if (method.getDeclaringClass().getName().equals(EJB_OBJECT_INTERFACE))
1615 continue;
1616
1617 if (!hasMatchingMethod(bean, method))
1618 {
1619 fireSpecViolationEvent(entity, method, new Section("9.2.7.e"));
1620 status = false;
1621 }
1622
1623 if (hasMatchingMethod(bean, method))
1624 {
1625 try
1626 {
1627 Method beanMethod = bean.getMethod(method.getName(),
1628 method.getParameterTypes());
1629
1630 if (!hasMatchingReturnType(beanMethod, method))
1631 {
1632 fireSpecViolationEvent(entity, method,
1633 new Section("9.2.7.f"));
1634 status = false;
1635 }
1636
1637 if (!hasMatchingExceptions(beanMethod, method))
1638 {
1639 fireSpecViolationEvent(entity, method,
1640 new Section("9.2.7.g"));
1641 status = false;
1642 }
1643 }
1644 catch (NoSuchMethodException ignored)
1645 {
1646 }
1647 }
1648 }
1649
1650 return status;
1651 }
1652
1653 /*
1654 * Verify Entity Bean Class
1655 */
1656 private boolean verifyCMPEntityBean(EntityMetaData entity)
1657 {
1658 boolean status = true;
1659
1660 // The enterprise bean class MUST implement, directly or
1661 // indirectly, the javax.ejb.EntityBean interface.
1662 //
1663 // Spec 10.6.2
1664 //
1665 if (!hasEntityBeanInterface(bean))
1666 {
1667 fireSpecViolationEvent(entity, new Section("10.6.2.a"));
1668 status = false;
1669 }
1670
1671 // The entity bean class MUST be defined as public and abstract.
1672 //
1673 // Spec 10.6.2
1674 //
1675 if (!isPublic(bean) || !isAbstract(bean))
1676 {
1677 fireSpecViolationEvent(entity, new Section("10.6.2.b"));
1678 status = false;
1679 }
1680
1681 // The entity bean class MUST define a public constructor that
1682 // takes no arguments
1683 //
1684 // Spec 10.6.2
1685 //
1686 if (!hasDefaultConstructor(bean))
1687 {
1688 fireSpecViolationEvent(entity, new Section("10.6.2.c"));
1689 status = false;
1690 }
1691
1692 // The entity bean class MUST NOT define the finalize() method.
1693 //
1694 // Spec 10.6.2
1695 //
1696 if (hasFinalizer(bean))
1697 {
1698 fireSpecViolationEvent(entity, new Section("10.6.2.d"));
1699 status = false;
1700 }
1701
1702 // The ejbCreate(...) method signatures MUST follow these rules:
1703 //
1704 // - The method MUST be declared as public
1705 // - The method MUST NOT be declared as final or static
1706 // - The return type MUST be the entity bean's primary key type
1707 // --- Only if method is on remote home ---
1708 // - The method arguments MUST be legal types for RMI/IIOP
1709 // - The method return value type MUST be legal type for RMI/IIOP
1710 // --- End of only if method is on remote home ---
1711 // - The method must define the javax.ejb.CreateException
1712 //
1713 // Spec 10.6.4
1714 //
1715 if (hasEJBCreateMethod(bean, false))
1716 {
1717 Iterator it = getEJBCreateMethods(bean);
1718 while (it.hasNext())
1719 {
1720 Method ejbCreate = (Method)it.next();
1721 if (!isPublic(ejbCreate))
1722 {
1723 fireSpecViolationEvent(entity, ejbCreate,
1724 new Section("10.6.4.b"));
1725 status = false;
1726 }
1727
1728 if ((isFinal(ejbCreate)) || (isStatic(ejbCreate)))
1729 {
1730 fireSpecViolationEvent(entity, ejbCreate,
1731 new Section("10.6.4.c"));
1732 status = false;
1733 }
1734
1735 if (!hasPrimaryKeyReturnType(entity, ejbCreate))
1736 {
1737 fireSpecViolationEvent(entity, ejbCreate,
1738 new Section("10.6.4.d"));
1739 status = false;
1740 }
1741
1742 /* FIXME
1743 * This is only true if the method is on the remote home
1744 * interface
1745 if (!hasLegalRMIIIOPArguments(ejbCreate)) {
1746 fireSpecViolationEvent(entity, ejbCreate, new Section("10.6.4.d"));
1747 status = false;
1748 }
1749
1750 if (!hasLegalRMIIIOPReturnType(ejbCreate)) {
1751 fireSpecViolationEvent(entity, ejbCreate, new Section("10.5.4.f"));
1752 status = false;
1753 }
1754 */
1755
1756 if (!throwsCreateException(ejbCreate))
1757 {
1758 fireSpecViolationEvent(entity, ejbCreate,
1759 new Section("10.6.4.g"));
1760 status = false;
1761 }
1762 }
1763 }
1764
1765 // For each ejbCreate(...) method, the entity bean class MUST
1766 // define a matching ejbPostCreate(...) method.
1767 //
1768 // The ejbPostCreate(...) method MUST follow these rules:
1769 //
1770 // - the method MUST be declared as public
1771 // - the method MUST NOT be declared as final or static
1772 // - the return type MUST be void
1773 // - the method arguments MUST be the same as the matching
1774 // ejbCreate(...) method
1775 //
1776 // Spec 10.6.5
1777 //
1778 if (hasEJBCreateMethod(bean, false))
1779 {
1780 Iterator it = getEJBCreateMethods(bean);
1781
1782 while (it.hasNext())
1783 {
1784 Method ejbCreate = (Method)it.next();
1785
1786 if (!hasMatchingEJBPostCreate(bean, ejbCreate))
1787 {
1788 fireSpecViolationEvent(entity, ejbCreate,
1789 new Section("10.6.5.a"));
1790 status = false;
1791 }
1792
1793 if (hasMatchingEJBPostCreate(bean, ejbCreate))
1794 {
1795 Method ejbPostCreate = getMatchingEJBPostCreate(bean,
1796 ejbCreate);
1797
1798 if (!isPublic(ejbPostCreate))
1799 {
1800 fireSpecViolationEvent(entity, ejbPostCreate,
1801 new Section("10.6.5.b"));
1802 status = false;
1803 }
1804
1805 if (isStatic(ejbPostCreate))
1806 {
1807 fireSpecViolationEvent(entity, ejbPostCreate,
1808 new Section("10.6.5.c"));
1809 status = false;
1810 }
1811
1812 if (isFinal(ejbPostCreate))
1813 {
1814 fireSpecViolationEvent(entity, ejbPostCreate,
1815 new Section("10.6.5.d"));
1816 status = false;
1817 }
1818
1819 if (!hasVoidReturnType(ejbPostCreate))
1820 {
1821 fireSpecViolationEvent(entity, ejbPostCreate,
1822 new Section("10.6.5.e"));
1823 status = false;
1824 }
1825 }
1826 }
1827 }
1828
1829 // The ejbHome(...) method signatures MUST follow these rules:
1830 //
1831 // - The method name MUST have ejbHome as its prefix.
1832 // - The method MUST be declared as public
1833 // - The method MUST NOT be declared as static.
1834 // - The method MUST NOT define the java.rmi.RemoteException
1835 //
1836 // Spec 10.6.6
1837 //
1838 Iterator it = getEjbHomeMethods(bean);
1839 while (it.hasNext())
1840 {
1841 Method ejbHome = (Method)it.next();
1842 if (!isPublic(ejbHome))
1843 {
1844 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.a"));
1845 status = false;
1846 }
1847
1848 if (isStatic(ejbHome))
1849 {
1850 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.b"));
1851 status = false;
1852 }
1853
1854 if (throwsRemoteException(ejbHome))
1855 {
1856 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.c"));
1857 status = false;
1858 }
1859 }
1860
1861 // The CMP entity bean MUST implement get and set accessor methods for
1862 // each field within the abstract persistance schema.
1863 //
1864 // Spec 10.6.2
1865 //
1866 it = entity.getCMPFields();
1867 while (it.hasNext())
1868 {
1869 String fieldName = (String)it.next();
1870 String getName = "get" + fieldName.substring(0, 1).toUpperCase() +
1871 fieldName.substring(1);
1872 Class fieldType = null;
1873
1874 try
1875 {
1876 Method m = bean.getMethod(getName, new Class[0]);
1877 fieldType = m.getReturnType();
1878
1879 // The getter must not return 'void' according to the JavaBeans
1880 // Spec
1881 if (fieldType == Void.TYPE)
1882 {
1883 fireSpecViolationEvent(entity,
1884 new Section("jb.7.1.b", "Field: " + fieldName));
1885 }
1886 }
1887 catch (NoSuchMethodException nsme)
1888 {
1889 fireSpecViolationEvent(entity,
1890 new Section("10.6.2.g", "Field: " + fieldName));
1891 status = false;
1892 }
1893
1894 String setName = "set" + fieldName.substring(0, 1).toUpperCase() +
1895 fieldName.substring(1);
1896 Class[] args = new Class[1];
1897 args[0] = fieldType;
1898
1899 try
1900 {
1901 Method m = bean.getMethod(setName, args);
1902 fieldType = m.getReturnType();
1903
1904 // According to the JavaBeans Spec, a setter method must
1905 // return 'void'
1906 if (fieldType != Void.TYPE)
1907 {
1908 fireSpecViolationEvent(entity,
1909 new Section("jb.7.1.a", "Field: " + fieldName));
1910 }
1911 }
1912 catch (NoSuchMethodException nsme)
1913 {
1914 // Try with java.util.Collection
1915 //
1916 // FIXME: This should only be tried for CMR methods; a CMP
1917 // setter cannot accept a Collection!
1918 try
1919 {
1920 args[0] = classloader.loadClass("java.util.Collection");
1921 Method m = bean.getMethod(setName, args);
1922 }
1923 catch (NoSuchMethodException nsme2)
1924 {
1925 fireSpecViolationEvent(entity,
1926 new Section("10.6.2.h", "Field: " + fieldName));
1927 status = false;
1928 }
1929 catch (ClassNotFoundException cnfe)
1930 {
1931 // Something is really broken
1932 }
1933 }
1934 }
1935
1936 // The ejbSelect(...) method signatures MUST follow these rules:
1937 //
1938 // - The method name MUST have ejbSelect as its prefix.
1939 // - The method MUST be declared as public
1940 // - The method MUST be declared as abstract.
1941 // - The method MUST define the javax.ejb.FinderException
1942 //
1943 // Spec 10.6.7
1944 //
1945 it = getEjbSelectMethods(bean);
1946 while (it.hasNext())
1947 {
1948 Method ejbSelect = (Method)it.next();
1949
1950 if (!isPublic(ejbSelect))
1951 {
1952 fireSpecViolationEvent(entity, ejbSelect, new Section("10.6.7.a"));
1953 status = false;
1954 }
1955
1956 if (!isAbstract(ejbSelect))
1957 {
1958 fireSpecViolationEvent(entity, ejbSelect, new Section("10.6.7.b"));
1959 status = false;
1960 }
1961
1962 if (!throwsFinderException(ejbSelect))
1963 {
1964 fireSpecViolationEvent(entity, ejbSelect, new Section("10.6.7.c"));
1965 status = false;
1966 }
1967
1968 if (!hasMatchingQuery(ejbSelect, entity))
1969 {
1970 fireSpecViolationEvent(entity, ejbSelect, new Section("10.5.7"));
1971 status = false;
1972 }
1973 }
1974
1975 // A CMP Entity Bean must not define Finder methods.
1976 //
1977 // Spec 10.6.2
1978 //
1979 if (hasFinderMethod(bean))
1980 {
1981 fireSpecViolationEvent(entity, new Section("10.6.2.i"));
1982 status = false;
1983 }
1984
1985 return status;
1986 }
1987
1988 /*
1989 * Verify BMP Entity Class
1990 */
1991 private boolean verifyBMPEntityBean(EntityMetaData entity)
1992 {
1993 boolean status = true;
1994
1995 // The enterprise bean class MUST implement, directly or
1996 // indirectly, the javax.ejb.EntityBean interface.
1997 //
1998 // Spec 12.2.2
1999 //
2000 if (!hasEntityBeanInterface(bean))
2001 {
2002 fireSpecViolationEvent(entity, new Section("12.2.2.a"));
2003 status = false;
2004 }
2005
2006 // The entity bean class MUST be defined as public and NOT abstract.
2007 //
2008 // Spec 12.2.2
2009 //
2010 if (!isPublic(bean) || isAbstract(bean))
2011 {
2012 fireSpecViolationEvent(entity, new Section("12.2.2.b"));
2013 status = false;
2014 }
2015
2016 // The entity bean class MUST NOT be defined as final.
2017 //
2018 // Spec 12.2.2
2019 //
2020 if (isFinal(bean))
2021 {
2022 fireSpecViolationEvent(entity, new Section("12.2.2.c"));
2023 status = false;
2024 }
2025
2026 // The entity bean class MUST define a public constructor that
2027 // takes no arguments
2028 //
2029 // Spec 12.2.2
2030 //
2031 if (!hasDefaultConstructor(bean))
2032 {
2033 fireSpecViolationEvent(entity, new Section("12.2.2.d"));
2034 status = false;
2035 }
2036
2037 // The entity bean class MUST NOT define the finalize() method.
2038 //
2039 // Spec 12.2.2
2040 //
2041 if (hasFinalizer(bean))
2042 {
2043 fireSpecViolationEvent(entity, new Section("12.2.2.e"));
2044 status = false;
2045 }
2046
2047 // The ejbCreate(...) method signatures MUST follow these rules:
2048 //
2049 // - The method MUST be declared as public
2050 // - The method MUST NOT be declared as final or static
2051 // - The return type MUST be the entity bean's primary key type
2052 // --- If the method is on the remote home interface ---
2053 // - The method arguments MUST be legal types for RMI/IIOP
2054 // - The method return value type MUST be legal type for RMI/IIOP
2055 // --- End if the method is on the remote home interface ---
2056 //
2057 // Spec 12.2.3
2058 //
2059 if (hasEJBCreateMethod(bean, false))
2060 {
2061 Iterator it = getEJBCreateMethods(bean);
2062 while (it.hasNext())
2063 {
2064 Method ejbCreate = (Method)it.next();
2065 if (!isPublic(ejbCreate))
2066 {
2067 fireSpecViolationEvent(entity, ejbCreate,
2068 new Section("12.2.3.a"));
2069 status = false;
2070 }
2071
2072 if ((isFinal(ejbCreate)) || (isStatic(ejbCreate)))
2073 {
2074 fireSpecViolationEvent(entity, ejbCreate,
2075 new Section("12.2.3.b"));
2076 status = false;
2077 }
2078
2079 if (!hasPrimaryKeyReturnType(entity, ejbCreate))
2080 {
2081 fireSpecViolationEvent(entity, ejbCreate,
2082 new Section("12.2.3.c"));
2083 status = false;
2084 }
2085
2086 /* FIXME
2087 * This code needs to only be invoked if the method is on the
2088 * remote home.
2089 if (!hasLegalRMIIIOPArguments(ejbCreate)) {
2090 fireSpecViolationEvent(entity, ejbCreate, new Section("9.2.3.d"));
2091 status = false;
2092 }
2093 if (!hasLegalRMIIIOPReturnType(ejbCreate)) {
2094 fireSpecViolationEvent(entity, ejbCreate, new Section("9.2.3.e"));
2095 status = false;
2096 }
2097 */
2098 }
2099 }
2100
2101 // For each ejbCreate(...) method, the entity bean class MUST
2102 // define a matching ejbPostCreate(...) method.
2103 //
2104 // The ejbPostCreate(...) method MUST follow these rules:
2105 //
2106 // - the method MUST be declared as public
2107 // - the method MUST NOT be declared as final or static
2108 // - the return type MUST be void
2109 // - the method arguments MUST be the same as the matching
2110 // ejbCreate(...) method
2111 //
2112 // Spec 12.2.4
2113 //
2114 if (hasEJBCreateMethod(bean, false))
2115 {
2116 Iterator it = getEJBCreateMethods(bean);
2117 while (it.hasNext())
2118 {
2119 Method ejbCreate = (Method)it.next();
2120
2121 if (!hasMatchingEJBPostCreate(bean, ejbCreate))
2122 {
2123 fireSpecViolationEvent(entity, ejbCreate,
2124 new Section("12.2.4.a"));
2125 status = false;
2126 }
2127
2128 if (hasMatchingEJBPostCreate(bean, ejbCreate))
2129 {
2130 Method ejbPostCreate = getMatchingEJBPostCreate(bean,
2131 ejbCreate);
2132
2133 if (!isPublic(ejbPostCreate))
2134 {
2135 fireSpecViolationEvent(entity, ejbPostCreate,
2136 new Section("12.2.4.b"));
2137 status = false;
2138 }
2139
2140 if (isStatic(ejbPostCreate) || isFinal(ejbPostCreate))
2141 {
2142 fireSpecViolationEvent(entity, ejbPostCreate,
2143 new Section("12.2.4.c"));
2144 status = false;
2145 }
2146
2147 if (!hasVoidReturnType(ejbPostCreate))
2148 {
2149 fireSpecViolationEvent(entity, ejbPostCreate,
2150 new Section("12.2.4.d"));
2151 status = false;
2152 }
2153 }
2154 }
2155 }
2156
2157 // Every entity bean MUST define the ejbFindByPrimaryKey method.
2158 //
2159 // The return type for the ejbFindByPrimaryKey method MUST be the
2160 // primary key type.
2161 //
2162 // The ejbFindByPrimaryKey method MUST be a single-object finder.
2163 //
2164 // Spec 12.2.5
2165 //
2166 if (!hasEJBFindByPrimaryKey(bean))
2167 {
2168 fireSpecViolationEvent(entity, new Section("12.2.5.e"));
2169 status = false;
2170 }
2171
2172 if (hasEJBFindByPrimaryKey(bean))
2173 {
2174 Method ejbFindByPrimaryKey = getEJBFindByPrimaryKey(bean);
2175
2176 if (!hasPrimaryKeyReturnType(entity, ejbFindByPrimaryKey))
2177 {
2178 fireSpecViolationEvent(entity, ejbFindByPrimaryKey,
2179 new Section("12.2.5.e1"));
2180 status = false;
2181 }
2182
2183 if (!isSingleObjectFinder(entity, ejbFindByPrimaryKey))
2184 {
2185 fireSpecViolationEvent(entity, ejbFindByPrimaryKey,
2186 new Section("12.2.5.e2"));
2187 status = false;
2188 }
2189 }
2190
2191 // A finder method MUST be declared as public.
2192 //
2193 // A finder method MUST NOT be declared as static.
2194 //
2195 // A finder method MUST NOT be declared as final.
2196 //
2197 // The finder method argument types MUST be legal types for
2198 // RMI/IIOP
2199 //
2200 // The finder method return type MUST be either the entity bean's
2201 // primary key type, or java.lang.util.Enumeration interface or
2202 // java.lang.util.Collection interface.
2203 //
2204 // Spec 12.2.5
2205 //
2206 if (hasFinderMethod(bean))
2207 {
2208 Iterator it = getEJBFindMethods(bean);
2209 while (it.hasNext())
2210 {
2211 Method finder = (Method)it.next();
2212
2213 if (!isPublic(finder))
2214 {
2215 fireSpecViolationEvent(entity, finder, new Section("12.2.5.a"));
2216 status = false;
2217 }
2218
2219 if (isFinal(finder) || isStatic(finder))
2220 {
2221 fireSpecViolationEvent(entity, finder, new Section("12.2.5.b"));
2222 status = false;
2223 }
2224
2225 /** FIXME
2226 * this path should only get invoked if the finder is on the
2227 * remote interface.
2228 if (!hasLegalRMIIIOPArguments(finder)) {
2229 fireSpecViolationEvent(entity, finder, new Section("12.2.5.c"));
2230 status = false;
2231 }
2232 */
2233
2234 if (!(isSingleObjectFinder(entity, finder)
2235 || isMultiObjectFinder(finder)))
2236 {
2237 fireSpecViolationEvent(entity, finder, new Section("12.2.5.d"));
2238 status = false;
2239 }
2240 }
2241 }
2242
2243 // The ejbHome(...) method signatures MUST follow these rules:
2244 //
2245 // - The method name MUST have ejbHome as its prefix.
2246 // - The method MUST be declared as public
2247 // - The method MUST NOT be declared as static.
2248 // - The method MUST NOT define the java.rmi.RemoteException
2249 //
2250 // Spec 10.6.6
2251 //
2252 Iterator it = getEjbHomeMethods(bean);
2253 while (it.hasNext())
2254 {
2255 Method ejbHome = (Method)it.next();
2256
2257 if (!isPublic(ejbHome))
2258 {
2259 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.a"));
2260 status = false;
2261 }
2262
2263 if (isStatic(ejbHome))
2264 {
2265 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.b"));
2266 status = false;
2267 }
2268
2269 if (throwsRemoteException(ejbHome))
2270 {
2271 fireSpecViolationEvent(entity, ejbHome, new Section("10.6.6.c"));
2272 status = false;
2273 }
2274 }
2275
2276 return status;
2277 }
2278
2279 /*
2280 * Verify Primary Key
2281 */
2282 private boolean verifyPrimaryKey(EntityMetaData entity)
2283 {
2284 boolean status = true;
2285 boolean cmp = entity.isCMP();
2286
2287 if (entity.getPrimaryKeyClass() == null
2288 || entity.getPrimaryKeyClass().length() == 0)
2289 {
2290 if (cmp)
2291 fireSpecViolationEvent(entity, new Section("10.6.1.a"));
2292 else
2293 fireSpecViolationEvent(entity, new Section("12.2.1.a"));
2294
2295 // We can't get any further if there's no PK class specified!
2296 return false;
2297 }
2298
2299 // FIXME - Still missing the bits from 10.8.2 for CMP primary
2300 // keys. Primarily the class must be public, all fields in the
2301 // class must be public and the fields must also be a subset of
2302 // the CMP fields within the bean.
2303 //
2304 Class cls = null;
2305 try
2306 {
2307 cls = classloader.loadClass(entity.getPrimaryKeyClass());
2308 }
2309 catch (ClassNotFoundException e)
2310 {
2311 if (cmp)
2312 fireSpecViolationEvent(entity, new Section("10.6.13.a"));
2313 else
2314 fireSpecViolationEvent(entity, new Section("12.2.12.a"));
2315
2316 // Can't do any other checks if the class is null!
2317 return false;
2318 }
2319
2320 // The primary key type must be a valid type in RMI-IIOP.
2321 //
2322 // Spec 10.6.13 & 12.2.12
2323 //
2324 if (!isRMIIDLValueType(cls))
2325 {
2326 if (cmp)
2327 fireSpecViolationEvent(entity, new Section("10.6.13.b"));
2328 else
2329 fireSpecViolationEvent(entity, new Section("12.2.12.b"));
2330 status = false;
2331 }
2332
2333 // No primary key field specified, just a primary key class.
2334 if (entity.getPrimKeyField() == null ||
2335 entity.getPrimKeyField().length() == 0)
2336 {
2337 // This is a check for some interesting implementation of
2338 // equals() and hashCode(). I am not sure how well it works in
2339 // the end.
2340 //
2341 if (!cls.getName().equals("java.lang.Object"))
2342 {
2343 Object one, two;
2344
2345 try
2346 {
2347 one = cls.newInstance();
2348 two = cls.newInstance();
2349 try
2350 {
2351 if (!one.equals(two))
2352 {
2353 if (cmp)
2354 {
2355 // fireSpecViolationEvent(entity, new Section("10.6.13.c"));
2356 log.warn("Default instances of primary key: " + cls
2357 + " do not equate, check your equals method");
2358 }
2359 else
2360 {
2361 //fireSpecViolationEvent(entity, new Section("12.2.12.c"));
2362 log.warn("Default instances of primary key: " + cls
2363 + " do not equate, check your equals method");
2364 }
2365 status = true;
2366 }
2367 }
2368 catch (NullPointerException e)
2369 {
2370 // That's OK - the implementor expected the fields to
2371 // have values
2372 }
2373
2374 try
2375 {
2376 if (one.hashCode() != two.hashCode())
2377 {
2378 if (cmp)
2379 {
2380 //fireSpecViolationEvent(entity, new Section("10.6.13.d"));
2381 log.warn("Default instances of primary key: " + cls
2382 + " do not have the same hash, check your hashCode method");
2383 }
2384 else
2385 {
2386 //fireSpecViolationEvent(entity, new Section("12.2.12.d"));
2387 log.warn("Default instances of primary key: " + cls
2388 + " do not have the same hash, check your hashCode method");
2389 }
2390 status = true;
2391 }
2392 }
2393 catch (NullPointerException e)
2394 {
2395 // That's OK - the implementor expected the fields to have values
2396 }
2397 }
2398 catch (IllegalAccessException e)
2399 {
2400 // If CMP primary key class MUST have a public
2401 // constructor with no parameters. 10.8.2.a
2402 ///
2403 if (cmp)
2404 {
2405 fireSpecViolationEvent(entity, new Section("10.8.2.a"));
2406 status = false;
2407 }
2408 }
2409 catch (InstantiationException e)
2410 {
2411 //Not sure what condition this is at the moment - JMW
2412 //fireSpecViolationEvent(entity, new Section("9.2.9.a"));
2413 //status = false;
2414 }
2415 }
2416 }
2417 else
2418 {
2419 // BMP Beans MUST not include the primkey-field element in
2420 // their deployment descriptor. Deployment descriptor comment
2421 //
2422 if (entity.isBMP())
2423 {
2424 fireSpecViolationEvent(entity, new Section("dd.a"));
2425 status = false;
2426 }
2427
2428 // The primary keyfield MUST be a CMP field within the
2429 // entity bean.
2430 //
2431 // Spec 10.8.1
2432 //
2433 boolean found = false;
2434 Iterator it = entity.getCMPFields();
2435 while (it.hasNext())
2436 {
2437 String fieldName = (String)it.next();
2438 if (fieldName.equals(entity.getPrimKeyField()))
2439 {
2440 found = true;
2441 break;
2442 }
2443 }
2444
2445 if (!found)
2446 {
2447 status = false;
2448 fireSpecViolationEvent(entity, new Section("10.8.1.b"));
2449 }
2450
2451 try
2452 {
2453 // The class of the primary key field MUST match the
2454 // primary key class specified for the entity bean. We
2455 // figure out the class of this field by getting the
2456 // return type of the get<FieldName> accessor method.
2457 //
2458 // Spec 10.8.1
2459 //
2460 String pkField = entity.getPrimKeyField();
2461 String methodName = "get" +
2462 pkField.substring(0, 1).toUpperCase() + pkField.substring(1);
2463
2464 Method method = bean.getMethod(methodName, new Class[0]);
2465 if (!entity.getPrimaryKeyClass().equals(method.getReturnType().getName())
2466 )
2467 {
2468 status = false;
2469 fireSpecViolationEvent(entity, new Section("10.8.1.a"));
2470 }
2471
2472 }
2473 catch (NoSuchMethodException e)
2474 {
2475 // The primary keyfield MUST be a CMP field within the
2476 // entity bean.
2477 //
2478 // Spec 10.8.1
2479 //
2480 status = false;
2481 fireSpecViolationEvent(entity, new Section("10.8.1.b"));
2482 }
2483 }
2484
2485 return status;
2486 }
2487
2488 /*
2489 * Verify Message Driven Bean
2490 */
2491 protected boolean verifyMessageDrivenBean(MessageDrivenMetaData mdBean)
2492 {
2493 boolean status = true;
2494
2495 // A message driven bean MUST implement, directly or indirectly,
2496 // javax.ejb.MessageDrivenBean interface.
2497 //
2498 // Spec 15.7.2
2499 //
2500 if (!hasMessageDrivenBeanInterface(bean))
2501 {
2502 fireSpecViolationEvent(mdBean, new Section("15.7.2.a"));
2503 status = false;
2504 }
2505
2506 // A message driven bean MUST implement, directly or indirectly,
2507 // javax.jms.MessageListener interface.
2508 //
2509 // Spec 15.7.2
2510 //
2511 if (!hasMessageListenerInterface(bean))
2512 {
2513 fireSpecViolationEvent(mdBean, new Section("15.7.2.b"));
2514 status = false;
2515 }
2516
2517 // The message driven bean class MUST be defined as public.
2518 //
2519 // Spec 15.7.2
2520 //
2521 if (!isPublic(bean))
2522 {
2523 fireSpecViolationEvent(mdBean, new Section("15.7.2.c1"));
2524 status = false;
2525 }
2526
2527 // The message driven bean class MUST NOT be final.
2528 //
2529 // Spec 15.7.2
2530 //
2531 if (isFinal(bean))
2532 {
2533 fireSpecViolationEvent(mdBean, new Section("15.7.2.c2"));
2534 status = false;
2535 }
2536
2537 // The message driven bean class MUST NOT be abstract.
2538 //
2539 // Spec 15.7.2
2540 //
2541 if (isAbstract(bean))
2542 {
2543 fireSpecViolationEvent(mdBean, new Section("15.7.2.c3"));
2544 status = false;
2545 }
2546
2547 // The message driven bean class MUST have a public constructor that
2548 // takes no arguments.
2549 //
2550 // Spec 15.7.2
2551 //
2552 if (!hasDefaultConstructor(bean))
2553 {
2554 fireSpecViolationEvent(mdBean, new Section("15.7.2.d"));
2555 status = false;
2556 }
2557
2558 // The message driven bean class MUST NOT define the finalize() method.
2559 //
2560 // Spec 15.7.2
2561 //
2562 if (hasFinalizer(bean))
2563 {
2564 fireSpecViolationEvent(mdBean, new Section("15.7.2.e"));
2565 status = false;
2566 }
2567
2568 // A message driven bean MUST implement the ejbCreate() method.
2569 // The ejbCreate() method signature MUST follow these rules:
2570 //
2571 // - The method name MUST be ejbCreate
2572 // - The method MUST be declared as public
2573 // - The method MUST NOT be declared as final or static
2574 // - The return type MUST be void
2575 // - The method arguments MUST have no arguments.
2576 // - The method MUST NOT define any application exceptions.
2577 //
2578 // Spec 15.7.2, 3
2579 //
2580 if (hasEJBCreateMethod(bean, false))
2581 {
2582 Iterator it = getEJBCreateMethods(bean);
2583 Method ejbCreate = (Method)it.next();
2584
2585 if (!isPublic(ejbCreate))
2586 {
2587 fireSpecViolationEvent(mdBean, ejbCreate, new Section("15.7.3.b"));
2588 status = false;
2589 }
2590
2591 if ((isFinal(ejbCreate)) || (isStatic(ejbCreate)))
2592 {
2593 fireSpecViolationEvent(mdBean, ejbCreate, new Section("15.7.3.c"));
2594 status = false;
2595 }
2596
2597 if (!hasVoidReturnType(ejbCreate))
2598 {
2599 fireSpecViolationEvent(mdBean, ejbCreate, new Section("15.7.3.d"));
2600 status = false;
2601 }
2602
2603 if (!hasNoArguments(ejbCreate))
2604 {
2605 fireSpecViolationEvent(mdBean, ejbCreate, new Section("15.7.3.e"));
2606 status = false;
2607 }
2608
2609 if (!throwsNoException(ejbCreate))
2610 {
2611 fireSpecViolationEvent(mdBean, ejbCreate, new Section("15.7.3.f"));
2612 status = false;
2613 }
2614
2615 if (it.hasNext())
2616 {
2617 fireSpecViolationEvent(mdBean, new Section("15.7.3.a"));
2618 status = false;
2619 }
2620 }
2621 else
2622 {
2623 fireSpecViolationEvent(mdBean, new Section("15.7.3.a"));
2624 status = false;
2625 }
2626
2627 // A message driven bean MUST implement the onMessage(...) method.
2628 // The onMessage() method signature MUST follow these rules:
2629 //
2630 // - The method name MUST be onMessage
2631 // - The method MUST be declared as public
2632 // - The method MUST NOT be declared as final or static
2633 // - The return type MUST be void
2634 // - The method arguments MUST have a single argument of type
2635 // javax.jms.Message.
2636 // - The method MUST NOT define any application exceptions.
2637 //
2638 // Spec 15.7.4
2639 //
2640 if (hasOnMessageMethod(bean))
2641 {
2642 Iterator it = getOnMessageMethods(bean);
2643 Method onMessage = (Method)it.next();
2644
2645 if (!isPublic(onMessage))
2646 {
2647 fireSpecViolationEvent(mdBean, onMessage, new Section("15.7.4.b"));
2648 status = false;
2649 }
2650
2651 if ((isFinal(onMessage)) || (isStatic(onMessage)))
2652 {
2653 fireSpecViolationEvent(mdBean, onMessage, new Section("15.7.4.c"));
2654 status = false;
2655 }
2656
2657 try
2658 {
2659 Class message = classloader.loadClass("javax.jms.Message");
2660 if (!hasSingleArgument(onMessage, message))
2661 {
2662 fireSpecViolationEvent(mdBean, onMessage,
2663 new Section("15.7.4.e"));
2664 status = false;
2665 }
2666
2667 if (!throwsNoException(onMessage))
2668 {
2669 fireSpecViolationEvent(mdBean, onMessage,
2670 new Section("15.7.4.f"));
2671 status = false;
2672 }
2673
2674 if (it.hasNext())
2675 {
2676 fireSpecViolationEvent(mdBean, new Section("15.7.4.a"));
2677 status = false;
2678 }
2679 }
2680 catch (ClassNotFoundException cnfe)
2681 {
2682 // javax.jms.Message is not available?!
2683 }
2684 }
2685 else
2686 {
2687 fireSpecViolationEvent(mdBean, new Section("15.7.4.a"));
2688 status = false;
2689 }
2690
2691 // A message driven bean MUST implement the ejbRemove() method.
2692 // The ejbRemove() method signature MUST follow these rules:
2693 //
2694 // - The method name MUST be ejbRemove
2695 // - The method MUST be declared as public
2696 // - The method MUST NOT be declared as final or static
2697 // - The return type MUST be void
2698 // - The method MUST have no arguments.
2699 // - The method MUST NOT define any application exceptions.
2700 //
2701 // Spec 15.7.5
2702 //
2703 if (hasEJBRemoveMethod(bean))
2704 {
2705 Iterator it = getEJBRemoveMethods(bean);
2706 Method ejbRemove = (Method)it.next();
2707
2708 if (!isPublic(ejbRemove))
2709 {
2710 fireSpecViolationEvent(mdBean, ejbRemove, new Section("15.7.5.b"));
2711 status = false;
2712 }
2713
2714 if ((isFinal(ejbRemove)) || (isStatic(ejbRemove)))
2715 {
2716 fireSpecViolationEvent(mdBean, ejbRemove, new Section("15.7.5.c"));
2717 status = false;
2718 }
2719
2720 if (!hasVoidReturnType(ejbRemove))
2721 {
2722 fireSpecViolationEvent(mdBean, ejbRemove, new Section("15.7.5.d"));
2723 status = false;
2724 }
2725
2726 if (!hasNoArguments(ejbRemove))
2727 {
2728 fireSpecViolationEvent(mdBean, ejbRemove, new Section("15.7.5.e"));
2729 status = false;
2730 }
2731
2732 if (!throwsNoException(ejbRemove))
2733 {
2734 fireSpecViolationEvent(mdBean, ejbRemove, new Section("15.7.5.f"));
2735 status = false;
2736 }
2737
2738 if (it.hasNext())
2739 {
2740 fireSpecViolationEvent(mdBean, new Section("15.7.5.a"));
2741 status = false;
2742 }
2743 }
2744 else
2745 {
2746 fireSpecViolationEvent(mdBean, new Section("15.7.5.a"));
2747 status = false;
2748 }
2749
2750 return status;
2751 }
2752
2753 }
2754
2755 /*
2756 vim:ts=3:sw=3:et
2757 */
Save This Page