Changeset 669 for raptor-client


Ignore:
Timestamp:
04/11/11 23:37:55 (9 years ago)
Author:
philsmart
Message:

added persistence classes

Location:
raptor-client/trunk
Files:
16 added
2 edited

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/pom.xml

    r663 r669  
    137137        </dependency> 
    138138 
    139  
    140  
    141         </dependencies> 
     139        <!--  Spring ORM and Hibernate for the DAO --> 
     140        <dependency> 
     141            <groupId>hibernate</groupId> 
     142            <artifactId>hibernate</artifactId> 
     143            <version>3.1rc2</version> 
     144        </dependency> 
     145 
     146 
     147        <dependency> 
     148                <groupId>org.springframework</groupId> 
     149                <artifactId>spring-orm</artifactId> 
     150                <version>3.0.2.RELEASE</version> 
     151        </dependency> 
     152    </dependencies> 
    142153 
    143154        <!-- 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/runtimeutils/ReflectionHelper.java

    r616 r669  
    1919package uk.ac.cardiff.raptor.runtimeutils; 
    2020 
     21import java.io.File; 
     22import java.io.FileInputStream; 
     23import java.lang.reflect.Field; 
    2124import java.lang.reflect.Method; 
     25import java.net.URL; 
     26import java.util.ArrayList; 
     27import java.util.List; 
     28import java.util.jar.JarEntry; 
     29import java.util.jar.JarInputStream; 
    2230 
    2331import org.slf4j.Logger; 
     
    2533 
    2634import uk.ac.cardiff.model.event.Event; 
     35 
    2736 
    2837/** 
     
    3443        /** Class logger */ 
    3544        private static final Logger log = LoggerFactory.getLogger(ReflectionHelper.class); 
    36  
    37         public static String prepareMethodNameSet(String method) { 
    38                 if (method.length() > 0) { 
    39                         String name = "set"; 
    40                         // now capitalise the first letter of the method name 
    41                         Character firstLetter = method.charAt(0); 
    42                         firstLetter = Character.toUpperCase(firstLetter); 
    43                         String newMethodName = method.substring(1, method.length()); 
    44                         name += firstLetter + newMethodName;                     
    45                         return name; 
    46  
    47                 } 
    48                 return method; 
    49  
    50         } 
    51  
    52         /** 
    53          * @param fieldname 
    54          * @return 
    55          */ 
    56         public static String prepareMethodNameGet(String method) { 
    57                 if (method.length() > 0) { 
    58                         String name = "get"; 
    59                         // now capitalise the first letter of the method name 
    60                         Character firstLetter = method.charAt(0); 
    61                         firstLetter = Character.toUpperCase(firstLetter); 
    62                         String newMethodName = method.substring(1, method.length()); 
    63                         name += firstLetter + newMethodName;                     
    64                         return name; 
    65  
    66                 } 
    67                 return method; 
    68         } 
    6945 
    7046        /** 
     
    12298 
    12399        } 
     100         
     101        public static String determineSubclassForMethods(String methodOne, String methodTwo) { 
     102                Object methodOneObject = findEntrySubclassForMethodAsObject(methodOne); 
     103                Object methodTwoObject = findEntrySubclassForMethodAsObject(methodTwo); 
     104                log.debug("Classes found, methodOne {}, methodTwo {}", methodOneObject.getClass(), methodTwoObject.getClass()); 
     105                // is methodTwoObject a superclass of methodOneObject, if it is, then 
     106                // its either an equivalent class 
     107                // or its a subclass so return it 
     108                log.debug("Is methodOne a superclass of methodTwo {}", 
     109                                (methodOneObject.getClass().isAssignableFrom(methodTwoObject.getClass()))); 
     110                if (methodTwoObject.getClass().isAssignableFrom(methodOneObject.getClass())) { 
     111                        return methodOneObject.getClass().getSimpleName(); 
     112                } else { 
     113                        return methodTwoObject.getClass().getSimpleName(); 
     114                } 
     115 
     116        } 
     117 
     118        public static List<String> getFieldsFromEntrySubClasses(){ 
     119                ArrayList<String> allFields = new ArrayList<String>(); 
     120                String forPckgName = "uk.ac.cardiff.model"; 
     121                String jarFile = getJARFilePath(forPckgName); 
     122                jarFile = jarFile.replace("file:", ""); 
     123                List<String> classes = getClasseNamesInPackageJAR(jarFile, forPckgName); 
     124 
     125                ArrayList allclasses = new ArrayList(); 
     126                for (String classname : classes) { 
     127                        try { 
     128                                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     129                                //if (o!=null)log.debug("found object {}",o.getClass()); 
     130                                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     131                                        allclasses.add(o); 
     132                                } 
     133                        } catch (ClassNotFoundException cnfex) { 
     134                                log.error("error getting subclasses of Entry, {}", cnfex); 
     135                        } catch (InstantiationException iex) { 
     136                                //log.error("{}", iex); 
     137                        } catch (IllegalAccessException iaex) { 
     138                                // The class is not public 
     139                                //log.error("{}", iaex); 
     140                        } 
     141                } 
     142                for (Object object : allclasses) { 
     143                        Field[] fields = object.getClass().getDeclaredFields(); 
     144                        for (Field field : fields){ 
     145                                allFields.add(field.getName()); 
     146                        } 
     147 
     148                } 
     149 
     150                return allFields; 
     151        } 
     152 
     153 
     154        public static Object findEntrySubclassForMethodAsObject(String fieldName) { 
     155                String forPckgName = "uk.ac.cardiff.model"; 
     156                String jarFile = getJARFilePath(forPckgName); 
     157                jarFile = jarFile.replace("file:", ""); 
     158                List<String> classes = getClasseNamesInPackageJAR(jarFile, forPckgName); 
     159                ArrayList allclasses = new ArrayList(); 
     160                for (String classname : classes) { 
     161                        try { 
     162                                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     163                                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     164                                        allclasses.add(o); 
     165                                } 
     166                        } catch (ClassNotFoundException cnfex) { 
     167                                log.error("{}", cnfex); 
     168                        } catch (InstantiationException iex) { 
     169                                // We try to instantiate an interface 
     170                                // or an object that does not have a 
     171                                // default constructor 
     172                        } catch (IllegalAccessException iaex) { 
     173                                // The class is not public 
     174                        } 
     175                } 
     176 
     177                Object objectWithMethod = null; 
     178                for (Object object : allclasses) { 
     179                        if (hasField(object, fieldName)) { 
     180                                objectWithMethod = object; 
     181                        } 
     182                } 
     183                if (objectWithMethod != null) { 
     184                        log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
     185                                        + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     186                        return objectWithMethod; 
     187                } 
     188 
     189                return null; 
     190 
     191        } 
     192 
     193        /** 
     194         * This method finds the simple name of the class in the uk.ac.cardiff.model 
     195         * package that contains the <code>fieldName</code>. 
     196         * 
     197         * @param fieldName 
     198         * @return 
     199         */ 
     200        public static String findEntrySubclassForMethod(String fieldName) { 
     201                String forPckgName = "uk.ac.cardiff.model"; 
     202                String jarFile = getJARFilePath(forPckgName); 
     203                jarFile = jarFile.replace("file:", ""); 
     204                List<String> classes = getClasseNamesInPackageJAR(jarFile, forPckgName); 
     205                ArrayList allclasses = new ArrayList(); 
     206                for (String classname : classes) { 
     207                        try { 
     208                                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     209                                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     210                                        // log.debug("Found classname: "+classname.replace(".class", 
     211                                        // "")); 
     212                                        allclasses.add(o); 
     213                                } 
     214                        } catch (ClassNotFoundException cnfex) { 
     215                                log.error("{}", cnfex); 
     216                        } catch (InstantiationException iex) { 
     217                                // We try to instantiate an interface 
     218                                // or an object that does not have a 
     219                                // default constructor 
     220                        } catch (IllegalAccessException iaex) { 
     221                                // The class is not public 
     222                        } 
     223                } 
     224 
     225                Object objectWithMethod = null; 
     226                for (Object object : allclasses) { 
     227                        if (hasField(object, fieldName)) { 
     228                                objectWithMethod = object; 
     229                        } 
     230                } 
     231                if (objectWithMethod != null) { 
     232                        log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
     233                                        + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     234                        return objectWithMethod.getClass().getSimpleName(); 
     235                } 
     236 
     237                return null; 
     238 
     239        } 
     240 
     241        /** 
     242         * Gets the name, as a string, of the JAR file that contains the package 
     243         * <code>pckgname</code> 
     244         * 
     245         * @param pckgname 
     246         * @return 
     247         */ 
     248        private static String getJARFilePath(String pckgname) { 
     249                String name = new String(pckgname); 
     250                if (!name.startsWith("/")) { 
     251                        name = "/" + name; 
     252                } 
     253                name = name.replace('.', '/'); 
     254                //log.debug("package name: " + name); 
     255                URL url = ReflectionHelper.class.getResource(name); 
     256                //log.debug("URL: "+url); 
     257                if (url != null && url.getPath().contains("!")) 
     258                        return url.getPath().substring(0, url.getPath().indexOf('!')); 
     259                else if (url != null) 
     260                        return url.getPath(); 
     261                else 
     262                        return null; 
     263        } 
     264 
     265        /** 
     266         * Gets the names of the classes, as strings, in the jar 
     267         * <code>jarName</code> and package <code>packageName</code> 
     268         * 
     269         * @param jarName 
     270         * @param packageName 
     271         * @return 
     272         */ 
     273        public static List<String> getClasseNamesInPackageJAR(String jarName, String packageName) { 
     274                ArrayList<String> classes = new ArrayList<String>(); 
     275                packageName = packageName.replaceAll("\\.", "/"); 
     276                try { 
     277                        JarInputStream jarFile = new JarInputStream(new FileInputStream(jarName)); 
     278                        JarEntry jarEntry; 
     279                        while (true) { 
     280                                jarEntry = jarFile.getNextJarEntry(); 
     281                                if (jarEntry == null) { 
     282                                        break; 
     283                                } 
     284                                if ((jarEntry.getName().startsWith(packageName)) && (jarEntry.getName().endsWith(".class"))) { 
     285                                        classes.add(jarEntry.getName().replaceAll("/", "\\.")); 
     286                                } 
     287                        } 
     288                } catch (Exception e) { 
     289                        e.printStackTrace(); 
     290                } 
     291                return classes; 
     292        } 
     293 
     294        /** 
     295         * Code taken and adapted from the JWhich project. Finds all subclasses of 
     296         * the uk.ac.cardiff.model.Entry class in the package <code>pckgname</code> 
     297         * if they exist outside any JAR libraries, use 
     298         * <code>getClasseNamesInPackageJAR</code> 
     299         * 
     300         * @param pckgname 
     301         * @return 
     302         */ 
     303        private static Object[] subclassesInDirectory(String pckgname) { 
     304                ArrayList<Object> allclasses = new ArrayList(); 
     305 
     306                String name = new String(pckgname); 
     307                if (!name.startsWith("/")) { 
     308                        name = "/" + name; 
     309                } 
     310                name = name.replace('.', '/'); 
     311 
     312                // Get a File object for the package 
     313                log.debug("package name: " + name); 
     314                URL url = ReflectionHelper.class.getResource(name); 
     315                log.debug("URL: " + url); 
     316                File directory = new File(url.getFile()); 
     317 
     318                // New code 
     319                // ====== 
     320                if (directory.exists()) { 
     321                        // Get the list of the files contained in the package 
     322                        String[] files = directory.list(); 
     323                        for (int i = 0; i < files.length; i++) { 
     324 
     325                                // we are only interested in .class files 
     326                                if (files[i].endsWith(".class")) { 
     327                                        // removes the .class extension 
     328                                        String classname = files[i].substring(0, files[i].length() - 6); 
     329                                        try { 
     330                                                log.debug("classname: " + classname); 
     331                                                // Try to create an instance of the object 
     332                                                Object o = Class.forName(pckgname + "." + classname).newInstance(); 
     333                                                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     334                                                        // log.debug("Found classname: "+classname); 
     335                                                        allclasses.add(o); 
     336                                                } 
     337                                        } catch (ClassNotFoundException cnfex) { 
     338                                                log.error("{}", cnfex); 
     339                                        } catch (InstantiationException iex) { 
     340                                                // We try to instantiate an interface 
     341                                                // or an object that does not have a 
     342                                                // default constructor 
     343                                        } catch (IllegalAccessException iaex) { 
     344                                                // The class is not public 
     345                                        } 
     346                                } 
     347                        } 
     348                } 
     349                return allclasses.toArray(); 
     350        } 
     351 
     352        /** 
     353         * Checks whether the Object <code>object</code> has the field 
     354         * <code>fieldName</code> 
     355         * 
     356         * @param object 
     357         * @param fieldName 
     358         * @return 
     359         */ 
     360        private static Boolean hasField(Object object, String fieldName) { 
     361                try { 
     362                        Field[] fields = object.getClass().getDeclaredFields(); 
     363                        for (Field field : fields) 
     364                                if (field.getName().equals(fieldName)) 
     365                                        return true; 
     366 
     367                } catch (Exception e) { 
     368                        e.printStackTrace(); 
     369                } 
     370                return false; 
     371 
     372        } 
     373 
     374        public static String prepareMethodNameSet(String method) { 
     375                if (method.length() > 0) { 
     376                        String name = "set"; 
     377                        // now capitalise the first letter of the method name 
     378                        Character firstLetter = method.charAt(0); 
     379                        firstLetter = Character.toUpperCase(firstLetter); 
     380                        String newMethodName = method.substring(1, method.length()); 
     381                        name += firstLetter + newMethodName; 
     382                        // System.out.println("method name: " + name); 
     383                        return name; 
     384 
     385                } 
     386                return method; 
     387 
     388        } 
     389 
     390        /** 
     391         * @param fieldname 
     392         * @return 
     393         */ 
     394        public static String prepareMethodNameGet(String method) { 
     395                if (method.length() > 0) { 
     396                        String name = "get"; 
     397                        // now capitalise the first letter of the method name 
     398                        Character firstLetter = method.charAt(0); 
     399                        firstLetter = Character.toUpperCase(firstLetter); 
     400                        String newMethodName = method.substring(1, method.length()); 
     401                        name += firstLetter + newMethodName; 
     402                        // System.out.println("method name: " + name); 
     403                        return name; 
     404 
     405                } 
     406                return method; 
     407        } 
     408 
     409        public static Object getValueFromObject(String fieldname, Object object) { 
     410                try { 
     411                        Class id = object.getClass(); 
     412                        String fieldAsMethod = ReflectionHelper.prepareMethodNameGet(fieldname); 
     413                        Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
     414                        // log.debug("Trying to Set :"+param) 
     415                        Object result = getter.invoke(object, new Object[] {}); 
     416                        return result; 
     417                } catch (Throwable e) { 
     418                        log.error("Field name '" + fieldname + "' does not match internal model attribute"); 
     419                        e.printStackTrace(); 
     420                        // System.exit(1); 
     421 
     422                } 
     423                return null; 
     424        } 
     425 
     426        public static void setValueOnObject(String fieldname, Object param, Object object) { 
     427                try { 
     428                        Class id = object.getClass(); 
     429                        String fieldAsMethod = ReflectionHelper.prepareMethodNameSet(fieldname); 
     430                        Method setter = id.getMethod(fieldAsMethod, new Class[] { param.getClass() }); 
     431                        // log.debug("Trying to Set :"+param) 
     432                        setter.invoke(object, new Object[] { param }); 
     433                } catch (Throwable e) { 
     434                        log.error("Field name '" + fieldname + "' does not match internal model attribute, or parameters are wrong"); 
     435                        // e.printStackTrace(); 
     436                        // System.exit(1); 
     437 
     438                } 
     439        } 
    124440 
    125441} 
Note: See TracChangeset for help on using the changeset viewer.