Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.axis2.jaxws.util; import org.apache.axis2.java.security.AccessController; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.io.IOException; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.Properties; import java.util.StringTokenizer; public class WSToolingUtils { private static final Log log = LogFactory.getLog(WSToolingUtils.class); /** * A handy function to check for empty or null string * * @param str * @return boolean * */ public static boolean hasValue(String str) { return ((str != null) && (str.length() > 0)); } /** * Retrieves the major version number of the WsGen class that we're using * * @return String * */ public static String getWsGenVersion() throws ClassNotFoundException, IOException { Class clazz = null; try { clazz = forName("com.sun.tools.ws.WsGen", false, getContextClassLoader(null)); } catch (ClassNotFoundException e1) { try { clazz = forName("com.sun.tools.internal.ws.WsGen", false, getContextClassLoader(null)); } catch (ClassNotFoundException e2) { if (log.isDebugEnabled()) { log.debug("Exception thrown from getWsGenVersion: " + e2.getMessage(), e2); } throw (ClassNotFoundException) e2; } } Properties p = new Properties(); try { p.load(clazz.getResourceAsStream("version.properties")); } catch (IOException ioex) { if (log.isDebugEnabled()) { log.debug("Exception thrown from getWsGenVersion: " + ioex.getMessage(), ioex); } throw (IOException) ioex.getCause(); } return (p.getProperty("major-version")); } /** * @return ClassLoader */ private static ClassLoader getContextClassLoader(final ClassLoader classLoader) { ClassLoader cl; try { cl = (ClassLoader) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return classLoader != null ? classLoader : Thread.currentThread().getContextClassLoader(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e.getMessage(), e); } throw ExceptionFactory.makeWebServiceException(e.getException()); } return cl; } /** * Return the class for this name * * @return Class */ private static Class forName(final String className, final boolean initialize, final ClassLoader classloader) throws ClassNotFoundException { Class cl = null; try { cl = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return Class.forName(className, initialize, classloader); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e.getMessage(), e); } throw (ClassNotFoundException) e.getException(); } return cl; } /** * Answer if the input version number is 2.1.6 or later. Version 2.1.6 is the Sun RI version that changed * the WebMethod annotation semantics. * * @param wsGenVersion A version number separated by "." Up to the first 3 values will be checked. * @return true if the version number is 2.1.6 or later, false otherwise. */ public static boolean isValidVersion(String wsGenVersion) { if (log.isDebugEnabled()) { log.debug("Start isValidVersion(String)"); } if (log.isDebugEnabled()) { log.debug("isValidVersion: Determining if WsGen version: " + wsGenVersion + " is appropriate version for using new SUN RI behavior"); } if (wsGenVersion == null) { return false; } /* * This algorithm is improvement over the old algorithm we had to validate the * version. In this algorithm we don't assume that the format will be x.x.x. * This algorithm looks for versionNumbers in a String token delimited by a * ".", the idea is to look for the first digit in each token and compare that * with the version validation requirements. * we return false if version is less that 2.1.6. * possible input version strings could be "JAX-WS RI 2.2-b05-", "2.1.6" "2.1.0" etc. */ // Minimum version required is 2.1.6 final int minimumVersionRequired[] = { 2, 1, 6 }; String version = wsGenVersion.trim(); StringTokenizer st = new StringTokenizer(version, "."); if (st.countTokens() <= 0) { if (log.isDebugEnabled()) { log.debug("No Tokens to validate the tooling version, Input version String is invalid."); } return false; } // Check up to as many version values as we have values in the minimum required version boolean lastCheckEqual = false; int tokenCnt = 0; for (; tokenCnt < minimumVersionRequired.length && st.hasMoreTokens(); tokenCnt++) { String token = st.nextToken(); if (token == null) { return false; } int versionNumber = getIntegerValue(token); int minimumVersionNumber = minimumVersionRequired[tokenCnt]; if (versionNumber < minimumVersionNumber) { // The version number is too low, so it is invalid if (log.isDebugEnabled()) { log.debug("Validation failed on tokenCnt = " + tokenCnt); log.debug("Input VersionNumber =" + versionNumber); log.debug("Minimum Version Number required = " + minimumVersionNumber); } return false; } else if (versionNumber > minimumVersionNumber) { // The version number is higher than required, so it passes validation. if (log.isDebugEnabled()) { log.debug("Validation passed on tokenCnt = " + tokenCnt); log.debug("Input VersionNumber = " + versionNumber); log.debug("Minimum Version Number required = " + minimumVersionNumber); } return true; } else { // The version number sub-value matches exactly, so we need to check the next sub-value.s if (log.isDebugEnabled()) { log.debug("Validation unresolved on tokenCnt = " + tokenCnt); log.debug("Input VersionNumber = " + versionNumber); log.debug("Minimum Version Number required = " + minimumVersionNumber); } lastCheckEqual = true; continue; } } if (log.isDebugEnabled()) { log.debug("Exit isValidVersion(String)"); } // If the version numbers we checked so far were equal to the minimum version BUT it was shorter // in length, then return false. For example if the input is "2.1", that is actually "2.1.0" // which would be less than "2.1.6". if (lastCheckEqual && tokenCnt < minimumVersionRequired.length) { return false; } return true; } /** * Parse the input string and return an integer value based on it. It will look for the first numeric value * in the string then use all digits up to the next non-numeric value or end of the string as the basis for * the value. For example "JAX-WS RI 27" will return the value 27. * @param s - String containing the integer to be returned. * @return a value or -1 if not integer value was found in the token. */ private static int getIntegerValue(String s) { int returnValue = -1; // Build up a buffer containing any digits up to the first non-numeric character. StringBuffer valueString = new StringBuffer(); for (int i = 0; i < s.length(); i++) { char ch = s.charAt(i); if (Character.isDigit(ch)) { valueString.append(Character.getNumericValue(ch)); } else if (valueString.length() > 0) { // We've found some numbers then encountered the first non-numeric value, so // exit the loop and use those numbers as the value break; } } // If there were any numeric values found in the string, convert them to the integer return value if (valueString.length() > 0) { returnValue = Integer.valueOf(valueString.toString()); } return returnValue; } }