1 22 package org.jboss.ejb.plugins.cmp.jdbc; 23 24 import java.lang.reflect.Method ; 25 import java.lang.reflect.Array ; 26 import java.lang.reflect.Constructor ; 27 28 import java.util.ArrayList ; 29 import java.util.Collection ; 30 import java.util.HashMap ; 31 import java.util.Iterator ; 32 import java.util.Map ; 33 import java.util.List ; 34 import java.util.Set ; 35 36 import javax.ejb.EJBException ; 37 38 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldMetaData; 39 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldPropertyMetaData; 40 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCTypeMappingMetaData; 41 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCValueClassMetaData; 42 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCValuePropertyMetaData; 43 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCUserTypeMappingMetaData; 44 import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCMappingMetaData; 45 import org.jboss.deployment.DeploymentException; 46 48 56 public final class JDBCTypeFactory 57 { 58 60 64 67 public static final CMPFieldStateFactory EQUALS = new CMPFieldStateFactory() 68 { 69 public Object getFieldState(Object fieldValue) 70 { 71 return fieldValue; 72 } 73 74 public boolean isStateValid(Object state, Object fieldValue) 75 { 76 return state == null ? fieldValue == null : state.equals(fieldValue); 77 } 78 }; 79 80 84 private static final CMPFieldStateFactory INVALID_UNLESS_NULL = new CMPFieldStateFactory() 85 { 86 public Object getFieldState(Object fieldValue) 87 { 88 return fieldValue; 89 } 90 91 public boolean isStateValid(Object state, Object fieldValue) 92 { 93 return state == null ? fieldValue == null : false; 94 } 95 }; 96 97 101 private static final CMPFieldStateFactory MAP = new CMPFieldStateFactory() 102 { 103 public Object getFieldState(Object fieldValue) 104 { 105 return cloneValue(fieldValue, Map .class); 106 } 107 108 public boolean isStateValid(Object state, Object fieldValue) 109 { 110 return (state == null ? fieldValue == null : state.equals(fieldValue)); 111 } 112 }; 113 114 118 private static final CMPFieldStateFactory LIST = new CMPFieldStateFactory() 119 { 120 public Object getFieldState(Object fieldValue) 121 { 122 return cloneValue(fieldValue, Collection .class); 123 } 124 125 public boolean isStateValid(Object state, Object fieldValue) 126 { 127 return (state == null ? fieldValue == null : state.equals(fieldValue)); 128 } 129 }; 130 131 135 private static final CMPFieldStateFactory SET = new CMPFieldStateFactory() 136 { 137 public Object getFieldState(Object fieldValue) 138 { 139 return cloneValue(fieldValue, Collection .class); 140 } 141 142 public boolean isStateValid(Object state, Object fieldValue) 143 { 144 return (state == null ? fieldValue == null : state.equals(fieldValue)); 145 } 146 }; 147 148 151 private static final CMPFieldStateFactory ARRAY = new CMPFieldStateFactory() 152 { 153 public Object getFieldState(Object fieldValue) 154 { 155 Object state = null; 156 if(fieldValue != null) 157 { 158 int length = Array.getLength(fieldValue); 159 state = Array.newInstance(fieldValue.getClass().getComponentType(), length); 160 System.arraycopy(fieldValue, 0, state, 0, length); 161 } 162 return state; 163 } 164 165 public boolean isStateValid(Object state, Object fieldValue) 166 { 167 boolean valid; 168 if(state == null) 169 { 170 valid = fieldValue == null; 171 } 172 else 173 { 174 if(fieldValue == null) 175 { 176 valid = false; 177 } 178 else 179 { 180 int stateLength = Array.getLength(state); 181 if(stateLength != Array.getLength(fieldValue)) 182 { 183 valid = false; 184 } 185 else 186 { 187 valid = true; 188 for(int i = 0; i < stateLength; ++i) 189 { 190 Object stateEl = Array.get(state, i); 191 Object valueEl = Array.get(fieldValue, i); 192 valid = (stateEl == null ? valueEl == null : stateEl.equals(valueEl)); 193 if(!valid) 194 { 195 break; 196 } 197 } 198 } 199 } 200 } 201 return valid; 202 } 203 }; 204 205 209 public static final CMPFieldStateFactory getCMPFieldStateFactory(JDBCTypeFactory factory, 210 String implClassName, 211 Class clazz) 212 throws DeploymentException 213 { 214 CMPFieldStateFactory stateFactory; 215 216 if(implClassName == null) 218 { 219 JDBCUserTypeMappingMetaData userMapping = (JDBCUserTypeMappingMetaData)factory.userTypeMappings.get(clazz.getName()); 220 if(userMapping != null) 221 { 222 implClassName = userMapping.getStateFactory(); 223 } 224 } 225 226 if(implClassName != null) 227 { 228 try 229 { 230 Class implClass = TCLAction.UTIL.getContextClassLoader().loadClass(implClassName); 231 stateFactory = (CMPFieldStateFactory)implClass.newInstance(); 232 } 233 catch(ClassNotFoundException e) 234 { 235 throw new DeploymentException("Could not load state factory class: " + implClassName); 236 } 237 catch(Exception e) 238 { 239 throw new DeploymentException("Failed instantiate state factory: " + implClassName); 240 } 241 } 242 else if(Map .class.isAssignableFrom(clazz)) 243 { 244 stateFactory = MAP; 245 } 246 else if(List .class.isAssignableFrom(clazz)) 247 { 248 stateFactory = LIST; 249 } 250 else if(Set .class.isAssignableFrom(clazz)) 251 { 252 stateFactory = SET; 253 } 254 else if(clazz.isArray()) 255 { 256 stateFactory = ARRAY; 257 } 258 else if(usedWithEqualsStateFactory(clazz)) 259 { 260 stateFactory = EQUALS; 261 } 262 else 263 { 264 stateFactory = INVALID_UNLESS_NULL; 265 } 266 return stateFactory; 267 } 268 269 public static final boolean checkDirtyAfterGet(JDBCTypeFactory factory, byte checkDirtyAfterGet, Class fieldType) 270 { 271 boolean result; 272 if(checkDirtyAfterGet == JDBCCMPFieldMetaData.CHECK_DIRTY_AFTER_GET_NOT_PRESENT) 273 { 274 JDBCUserTypeMappingMetaData userMapping = (JDBCUserTypeMappingMetaData)factory. 275 userTypeMappings.get(fieldType.getName()); 276 if(userMapping != null && 277 userMapping.checkDirtyAfterGet() != JDBCCMPFieldMetaData.CHECK_DIRTY_AFTER_GET_NOT_PRESENT) 278 { 279 result = userMapping.checkDirtyAfterGet() == JDBCCMPFieldMetaData.CHECK_DIRTY_AFTER_GET_TRUE; 280 } 281 else 282 { 283 result = !isDefaultImmutable(fieldType); 284 } 285 } 286 else 287 { 288 result = checkDirtyAfterGet == JDBCCMPFieldMetaData.CHECK_DIRTY_AFTER_GET_TRUE; 289 } 290 return result; 291 } 292 293 private static Object cloneValue(Object fieldValue, Class argType) 294 { 295 if(fieldValue == null) 296 { 297 return null; 298 } 299 300 Class valueType = fieldValue.getClass(); 301 Constructor ctor; 302 try 303 { 304 ctor = valueType.getConstructor(new Class []{argType}); 305 } 306 catch(NoSuchMethodException e) 307 { 308 throw new IllegalStateException ( 309 "Failed to find a ctor in " + valueType + 310 " that takes an instance of " + argType + " as an argument." 311 ); 312 } 313 314 try 315 { 316 return ctor.newInstance(new Object []{fieldValue}); 317 } 318 catch(Exception e) 319 { 320 throw new IllegalStateException ( 321 "Failed to create an instance of " + valueType + 322 " with the " + fieldValue + " as a ctor argument" 323 ); 324 } 325 } 326 327 private static final boolean usedWithEqualsStateFactory(Class clazz) 328 { 329 return 330 isDefaultImmutable(clazz) || 331 clazz == java.util.Date .class || 332 clazz == java.sql.Date .class || 333 clazz == java.sql.Time .class || 334 clazz == java.sql.Timestamp .class; 335 } 336 337 private static final boolean isDefaultImmutable(Class clazz) 338 { 339 boolean result = false; 340 if(clazz.isPrimitive() 341 || clazz == Boolean .class 342 || clazz == Byte .class 343 || clazz == Short .class 344 || clazz == Integer .class 345 || clazz == Long .class 346 || clazz == Float .class 347 || clazz == Double .class 348 || clazz == Character .class 349 || clazz == String .class 350 || clazz == java.math.BigInteger .class 351 || clazz == java.math.BigDecimal .class 352 ) 353 { 354 result = true; 355 } 356 return result; 357 } 358 359 363 private final JDBCTypeMappingMetaData typeMapping; 365 366 private final Map complexTypes = new HashMap (); 368 private final Map mappedSimpleTypes = new HashMap (); 369 370 371 private final Map userTypeMappings; 372 373 public JDBCTypeFactory(JDBCTypeMappingMetaData typeMapping, 374 Collection valueClasses, 375 Map userTypeMappings) throws DeploymentException 376 { 377 this.typeMapping = typeMapping; 378 this.userTypeMappings = userTypeMappings; 379 380 HashMap valueClassesByType = new HashMap (); 381 for(Iterator i = valueClasses.iterator(); i.hasNext();) 382 { 383 JDBCValueClassMetaData valueClass = (JDBCValueClassMetaData)i.next(); 384 valueClassesByType.put(valueClass.getJavaType(), valueClass); 385 } 386 387 388 for(Iterator i = valueClasses.iterator(); i.hasNext();) 390 { 391 JDBCValueClassMetaData valueClass = (JDBCValueClassMetaData)i.next(); 392 JDBCTypeComplex type = createTypeComplex(valueClass, valueClassesByType); 393 complexTypes.put(valueClass.getJavaType(), type); 394 } 395 396 Iterator i = typeMapping.getMappings().iterator(); 397 while(i.hasNext()) 398 { 399 JDBCMappingMetaData mapping = (JDBCMappingMetaData)i.next(); 400 401 String sqlType = mapping.getSqlType(); 402 int jdbcType = mapping.getJdbcType(); 403 Class javaType = loadClass(mapping.getJavaType()); 404 boolean notNull = javaType.isPrimitive(); 405 boolean autoIncrement = false; 406 407 JDBCParameterSetter paramSetter; 408 if(mapping.getParamSetter() != null) 409 { 410 paramSetter = (JDBCParameterSetter)newInstance(mapping.getParamSetter()); 411 } 412 else 413 { 414 paramSetter = JDBCUtil.getParameterSetter(jdbcType, javaType); 415 } 416 417 JDBCResultSetReader resultReader; 418 if(mapping.getResultReader() != null) 419 { 420 resultReader = (JDBCResultSetReader)newInstance(mapping.getResultReader()); 421 } 422 else 423 { 424 resultReader = JDBCUtil.getResultSetReader(jdbcType, javaType); 425 } 426 427 JDBCTypeSimple type = new JDBCTypeSimple( 428 null, javaType, jdbcType, sqlType, notNull, autoIncrement, null, paramSetter, resultReader 429 ); 430 mappedSimpleTypes.put(javaType, type); 431 } 432 } 433 434 public JDBCType getJDBCType(Class javaType) 435 { 436 if(complexTypes.containsKey(javaType)) 437 { 438 return (JDBCTypeComplex)complexTypes.get(javaType); 439 } 440 else 441 { 442 JDBCTypeSimple type = (JDBCTypeSimple)mappedSimpleTypes.get(javaType); 443 if(type == null) 444 { 445 JDBCUserTypeMappingMetaData userTypeMapping = 446 (JDBCUserTypeMappingMetaData)userTypeMappings.get(javaType.getName()); 447 Mapper mapper = null; 448 if(userTypeMapping != null) 449 { 450 ClassLoader cl = Thread.currentThread().getContextClassLoader(); 451 try 452 { 453 javaType = cl.loadClass(userTypeMapping.getMappedType()); 454 } 455 catch(ClassNotFoundException e) 456 { 457 throw new IllegalStateException ("Failed to load mapped type: " + userTypeMapping.getMappedType()); 458 } 459 460 try 461 { 462 mapper = (Mapper)newInstance(userTypeMapping.getMapper()); 463 } 464 catch(DeploymentException e) 465 { 466 throw new IllegalStateException ("Failed to create Mapper instance of " + userTypeMapping.getMapper()); 467 } 468 } 469 470 JDBCMappingMetaData typeMappingMD = typeMapping.getTypeMappingMetaData(javaType); 471 String sqlType = typeMappingMD.getSqlType(); 472 int jdbcType = typeMappingMD.getJdbcType(); 473 boolean notNull = javaType.isPrimitive(); 474 boolean autoIncrement = false; 475 476 JDBCParameterSetter paramSetter; 477 if(typeMappingMD.getParamSetter() != null) 478 { 479 try 480 { 481 paramSetter = (JDBCParameterSetter)newInstance(typeMappingMD.getParamSetter()); 482 } 483 catch(DeploymentException e) 484 { 485 throw new IllegalStateException (e.getMessage()); 486 } 487 } 488 else 489 { 490 paramSetter = JDBCUtil.getParameterSetter(jdbcType, javaType); 491 } 492 493 JDBCResultSetReader resultReader; 494 if(typeMappingMD.getResultReader() != null) 495 { 496 try 497 { 498 resultReader = (JDBCResultSetReader)newInstance(typeMappingMD.getResultReader()); 499 } 500 catch(DeploymentException e) 501 { 502 throw new IllegalStateException (e.getMessage()); 503 } 504 } 505 else 506 { 507 resultReader = JDBCUtil.getResultSetReader(jdbcType, javaType); 508 } 509 510 type = new JDBCTypeSimple( 511 null, javaType, jdbcType, sqlType, notNull, autoIncrement, mapper, paramSetter, resultReader 512 ); 513 } 514 return type; 515 } 516 } 517 518 public JDBCType getJDBCType(JDBCCMPFieldMetaData cmpField) throws DeploymentException 519 { 520 JDBCType fieldJDBCType; 521 final Class fieldType = cmpField.getFieldType(); 522 if(complexTypes.containsKey(fieldType)) 523 { 524 fieldJDBCType = createTypeComplex(cmpField); 525 } 526 else 527 { 528 fieldJDBCType = createTypeSimple(cmpField); 529 } 530 return fieldJDBCType; 531 } 532 533 public int getJDBCTypeForJavaType(Class clazz) 534 { 535 return typeMapping.getTypeMappingMetaData(clazz).getJdbcType(); 536 } 537 538 public JDBCTypeMappingMetaData getTypeMapping() 539 { 540 return typeMapping; 541 } 542 543 private JDBCTypeComplex createTypeComplex( 544 JDBCValueClassMetaData valueClass, 545 HashMap valueClassesByType) 546 { 547 ArrayList propertyList = createComplexProperties(valueClass, valueClassesByType, new PropertyStack()); 549 550 JDBCTypeComplexProperty[] properties = new JDBCTypeComplexProperty[propertyList.size()]; 552 properties = (JDBCTypeComplexProperty[])propertyList.toArray(properties); 553 554 return new JDBCTypeComplex(properties, valueClass.getJavaType()); 555 } 556 557 private JDBCTypeSimple createTypeSimple(JDBCCMPFieldMetaData cmpField) throws DeploymentException 558 { 559 String columnName = cmpField.getColumnName(); 560 Class javaType = cmpField.getFieldType(); 561 562 JDBCMappingMetaData typeMappingMD = typeMapping.getTypeMappingMetaData(javaType); 563 String paramSetter = typeMappingMD.getParamSetter(); 564 String resultReader = typeMappingMD.getResultReader(); 565 566 int jdbcType; 567 String sqlType = cmpField.getSQLType(); 568 if(sqlType != null) 569 { 570 jdbcType = cmpField.getJDBCType(); 571 } 572 else 573 { 574 sqlType = typeMappingMD.getSqlType(); 576 jdbcType = typeMappingMD.getJdbcType(); 577 } 578 579 boolean notNull = cmpField.isNotNull(); 580 boolean autoIncrement = cmpField.isAutoIncrement(); 581 582 Mapper mapper = null; 583 JDBCUserTypeMappingMetaData userTypeMapping = (JDBCUserTypeMappingMetaData)userTypeMappings.get(javaType.getName()); 584 if(userTypeMapping != null) 585 { 586 String mappedTypeStr = userTypeMapping.getMappedType(); 587 try 588 { 589 final ClassLoader contextClassLoader = TCLAction.UTIL.getContextClassLoader(); 590 Class mapperClass = contextClassLoader.loadClass(userTypeMapping.getMapper()); 591 mapper = (Mapper)mapperClass.newInstance(); 592 javaType = contextClassLoader.loadClass(mappedTypeStr); 593 if(cmpField.getSQLType() == null) 594 { 595 JDBCMappingMetaData mappingMD = typeMapping.getTypeMappingMetaData(javaType); 596 sqlType = mappingMD.getSqlType(); 597 jdbcType = mappingMD.getJdbcType(); 598 paramSetter = mappingMD.getParamSetter(); 599 resultReader = mappingMD.getResultReader(); 600 } 601 } 602 catch(ClassNotFoundException e) 603 { 604 throw new DeploymentException("Class not found for mapper: " + userTypeMapping.getMapper(), e); 605 } 606 catch(Exception e) 607 { 608 throw new DeploymentException("Could not instantiate mapper: " + userTypeMapping.getMapper(), e); 609 } 610 } 611 612 JDBCParameterSetter paramSetterImpl; 613 if(paramSetter == null) 614 { 615 paramSetterImpl = JDBCUtil.getParameterSetter(jdbcType, javaType); 616 } 617 else 618 { 619 paramSetterImpl = (JDBCParameterSetter)newInstance(paramSetter); 620 } 621 622 JDBCResultSetReader resultReaderImpl; 623 if(resultReader == null) 624 { 625 resultReaderImpl = JDBCUtil.getResultSetReader(jdbcType, javaType); 626 } 627 else 628 { 629 resultReaderImpl = (JDBCResultSetReader)newInstance(resultReader); 630 } 631 632 return new JDBCTypeSimple( 633 columnName, 634 javaType, 635 jdbcType, 636 sqlType, 637 notNull, 638 autoIncrement, 639 mapper, 640 paramSetterImpl, 641 resultReaderImpl 642 ); 643 } 644 645 private JDBCTypeComplex createTypeComplex(JDBCCMPFieldMetaData cmpField) 646 { 647 JDBCTypeComplex type = (JDBCTypeComplex)complexTypes.get(cmpField.getFieldType()); 649 JDBCTypeComplexProperty[] defaultProperties = type.getProperties(); 650 651 HashMap overrides = new HashMap (); 653 654 for(int i = 0; i < cmpField.getPropertyOverrides().size(); ++i) 655 { 656 JDBCCMPFieldPropertyMetaData p = (JDBCCMPFieldPropertyMetaData)cmpField.getPropertyOverrides().get(i); 657 overrides.put(p.getPropertyName(), p); 658 } 659 660 JDBCTypeComplexProperty[] finalProperties = new JDBCTypeComplexProperty[defaultProperties.length]; 662 663 for(int i = 0; i < defaultProperties.length; i++) 665 { 666 JDBCCMPFieldPropertyMetaData override; 668 override = (JDBCCMPFieldPropertyMetaData)overrides.remove(defaultProperties[i].getPropertyName()); 669 670 if(override == null) 671 { 672 finalProperties[i] = defaultProperties[i]; 673 finalProperties[i] = new JDBCTypeComplexProperty( 674 defaultProperties[i], 675 cmpField.getColumnName() + "_" + 676 defaultProperties[i].getColumnName(), 677 defaultProperties[i].getJDBCType(), 678 defaultProperties[i].getSQLType(), 679 cmpField.isNotNull() || defaultProperties[i].isNotNull()); 680 } 681 else 682 { 683 String columnName = override.getColumnName(); 685 if(columnName == null) 686 { 687 columnName = cmpField.getColumnName() + "_" + defaultProperties[i].getColumnName(); 688 } 689 690 String sqlType = override.getSQLType(); 692 int jdbcType; 693 if(sqlType != null) 694 { 695 jdbcType = override.getJDBCType(); 696 } 697 else 698 { 699 sqlType = defaultProperties[i].getSQLType(); 700 jdbcType = defaultProperties[i].getJDBCType(); 701 } 702 703 boolean notNull = cmpField.isNotNull() || 704 override.isNotNull() || 705 defaultProperties[i].isNotNull(); 706 707 finalProperties[i] = new JDBCTypeComplexProperty( 708 defaultProperties[i], 709 columnName, 710 jdbcType, 711 sqlType, 712 notNull); 713 } 714 } 715 716 if(overrides.size() > 0) 718 { 719 String propertyName = (String )overrides.keySet().iterator().next(); 720 throw new EJBException ("Property " + propertyName + " in field " + 721 cmpField.getFieldName() + " is not a property of value object " + 722 cmpField.getFieldType().getName()); 723 } 724 725 return new JDBCTypeComplex(finalProperties, cmpField.getFieldType()); 727 } 728 729 private ArrayList createComplexProperties( 730 JDBCValueClassMetaData valueClass, 731 HashMap valueClassesByType, 732 PropertyStack propertyStack) 733 { 734 735 ArrayList properties = new ArrayList (); 736 737 java.util.List valueClassProperties = valueClass.getProperties(); 739 for(int i = 0; i < valueClassProperties.size(); ++i) 740 { 741 JDBCValuePropertyMetaData propertyMetaData = 742 (JDBCValuePropertyMetaData)valueClassProperties.get(i); 743 properties.addAll(createComplexProperties(propertyMetaData, 744 valueClassesByType, propertyStack)); 745 } 746 return properties; 747 } 748 749 private ArrayList createComplexProperties( 750 JDBCValuePropertyMetaData propertyMetaData, 751 HashMap valueClassesByType, 752 PropertyStack propertyStack) 753 { 754 755 propertyStack.pushPropertyMetaData(propertyMetaData); 757 758 ArrayList properties = new ArrayList (); 759 760 Class javaType = propertyMetaData.getPropertyType(); 761 if(!valueClassesByType.containsKey(javaType)) 762 { 763 764 String propertyName = propertyStack.getPropertyName(); 767 String columnName = propertyStack.getColumnName(); 768 769 String sqlType = propertyMetaData.getSqlType(); 770 int jdbcType; 771 if(sqlType != null) 772 { 773 jdbcType = propertyMetaData.getJDBCType(); 774 } 775 else 776 { 777 JDBCMappingMetaData typeMappingMD = typeMapping.getTypeMappingMetaData(javaType); 779 sqlType = typeMappingMD.getSqlType(); 780 jdbcType = typeMappingMD.getJdbcType(); 781 } 782 783 boolean notNull = propertyStack.isNotNull(); 784 785 Method [] getters = propertyStack.getGetters(); 786 Method [] setters = propertyStack.getSetters(); 787 788 properties.add(new JDBCTypeComplexProperty( 789 propertyName, 790 columnName, 791 javaType, 792 jdbcType, 793 sqlType, 794 notNull, 795 getters, 796 setters)); 797 798 } 799 else 800 { 801 802 JDBCValueClassMetaData valueClass = 804 (JDBCValueClassMetaData)valueClassesByType.get(javaType); 805 properties.addAll(createComplexProperties( 806 valueClass, 807 valueClassesByType, 808 propertyStack)); 809 810 } 811 812 propertyStack.popPropertyMetaData(); 814 815 return properties; 816 } 817 818 private static final class PropertyStack 819 { 820 final ArrayList properties = new ArrayList (); 821 final ArrayList propertyNames = new ArrayList (); 822 final ArrayList columnNames = new ArrayList (); 823 final ArrayList notNulls = new ArrayList (); 824 final ArrayList getters = new ArrayList (); 825 final ArrayList setters = new ArrayList (); 826 827 public PropertyStack() 828 { 829 } 830 831 public final void pushPropertyMetaData( 832 JDBCValuePropertyMetaData propertyMetaData) 833 { 834 835 propertyNames.add(propertyMetaData.getPropertyName()); 836 columnNames.add(propertyMetaData.getColumnName()); 837 notNulls.add(new Boolean (propertyMetaData.isNotNull())); 838 getters.add(propertyMetaData.getGetter()); 839 setters.add(propertyMetaData.getSetter()); 840 841 if(properties.contains(propertyMetaData)) 842 { 843 throw new EJBException ("Circular reference discoverd at " + 844 "property: " + getPropertyName()); 845 } 846 properties.add(propertyMetaData); 847 } 848 849 public final void popPropertyMetaData() 850 { 851 propertyNames.remove(propertyNames.size() - 1); 852 columnNames.remove(columnNames.size() - 1); 853 notNulls.remove(notNulls.size() - 1); 854 getters.remove(getters.size() - 1); 855 setters.remove(setters.size() - 1); 856 857 properties.remove(properties.size() - 1); 858 } 859 860 public final String getPropertyName() 861 { 862 StringBuffer buf = new StringBuffer (); 863 for(int i = 0; i < propertyNames.size(); i++) 864 { 865 if(i > 0) 866 { 867 buf.append("."); 868 } 869 buf.append((String )propertyNames.get(i)); 870 } 871 return buf.toString(); 872 } 873 874 public final String getColumnName() 875 { 876 StringBuffer buf = new StringBuffer (); 877 for(int i = 0; i < columnNames.size(); i++) 878 { 879 if(i > 0) 880 { 881 buf.append("_"); 882 } 883 buf.append((String )columnNames.get(i)); 884 } 885 return buf.toString(); 886 } 887 888 public final boolean isNotNull() 889 { 890 for(int i = 0; i < notNulls.size(); i++) 891 { 892 if(((Boolean )notNulls.get(i)).booleanValue()) 893 { 894 return true; 895 } 896 } 897 return false; 898 } 899 900 public final Method [] getGetters() 901 { 902 return (Method [])getters.toArray(new Method [getters.size()]); 903 } 904 905 public final Method [] getSetters() 906 { 907 return (Method [])setters.toArray(new Method [setters.size()]); 908 } 909 } 910 911 912 private Object newInstance(String className) throws DeploymentException 913 { 914 Class clazz = loadClass(className); 915 try 916 { 917 return clazz.newInstance(); 918 } 919 catch(Exception e) 920 { 921 throw new DeploymentException("Failed to instantiate " + className, e); 922 } 923 } 924 private Class loadClass(String className) throws DeploymentException 925 { 926 try 927 { 928 final ClassLoader contextClassLoader = TCLAction.UTIL.getContextClassLoader(); 929 return contextClassLoader.loadClass(className); 930 } 931 catch(ClassNotFoundException e) 932 { 933 throw new DeploymentException("Failed to load class: " + className, e); 934 } 935 } 936 } 937 | Popular Tags |