Java UrlValidator类代码示例

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
private void sendSlackImageResponse(ObjectNode json, String s3Key) {
	try {
		ObjectMapper mapper = new ObjectMapper();
		ObjectNode message = mapper.createObjectNode();
		ArrayNode attachments = mapper.createArrayNode();
		ObjectNode attachment = mapper.createObjectNode();

		String emoji = json.get("text").asText();

		if (UrlValidator.getInstance().isValid(emoji)) {
			attachment.put("title_link", emoji);
			emoji = StringUtils.substringAfterLast(emoji, "/");
		}

		String username = json.get("user_name").asText();
		String responseUrl = json.get("response_url").asText();
		String slackChannelId = json.get("channel_id").asText();
		String imageUrl = String.format("https://s3.amazonaws.com/%s/%s", PROPERTIES.getProperty(S3_BUCKET_NAME), s3Key);

		message.put("response_type", "in_channel");
		message.put("channel_id", slackChannelId);
		attachment.put("title", resolveMessage("slackImageResponse", emoji, username));
		attachment.put("fallback", resolveMessage("approximated", emoji));
		attachment.put("image_url", imageUrl);
		attachments.add(attachment);
		message.set("attachments", attachments);

		HttpClient client = HttpClientBuilder.create().build();
		HttpPost slackResponseReq = new HttpPost(responseUrl);
		slackResponseReq.setEntity(new StringEntity(mapper.writeValueAsString(message), ContentType.APPLICATION_JSON));
		HttpResponse slackResponse = client.execute(slackResponseReq);
		int status = slackResponse.getStatusLine().getStatusCode();
		LOG.info("Got {} status from Slack API after sending approximation to response url.", status);
	} catch (UnsupportedOperationException | IOException e) {
		LOG.error("Exception occured when sending Slack response", e);
	}
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
@Override
public URL determineLogoutUrl(final RegisteredService registeredService, final WebApplicationService singleLogoutService) {
    try {
        final URL serviceLogoutUrl = registeredService.getLogoutUrl();
        if (serviceLogoutUrl != null) {
            LOGGER.debug("Logout request will be sent to [{}] for service [{}]", serviceLogoutUrl, singleLogoutService);
            return serviceLogoutUrl;
        }
        if (UrlValidator.getInstance().isValid(singleLogoutService.getOriginalUrl())) {
            return new URL(singleLogoutService.getOriginalUrl());
        }
        return null;
    } catch (final Exception e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
/**
 * Validates a given JSON Object against the default profile schema.
 * @param jsonObjectToValidate
 * @throws IOException
 * @throws DataPackageException
 * @throws ValidationException 
 */
public void validate(JSONObject jsonObjectToValidate) throws IOException, DataPackageException, ValidationException{
    
    // If a profile value is provided.
    if(jsonObjectToValidate.has(Package.JSON_KEY_PROFILE)){
        String profile = jsonObjectToValidate.getString(Package.JSON_KEY_PROFILE);
        
        String[] schemes = {"http", "https"};
        UrlValidator urlValidator = new UrlValidator(schemes);
        
        if (urlValidator.isValid(profile)) {
            this.validate(jsonObjectToValidate, new URL(profile));
        }else{
            this.validate(jsonObjectToValidate, profile);
        }
        
    }else{
        // If no profile value is provided, use default value.
        this.validate(jsonObjectToValidate, Profile.PROFILE_DEFAULT);
    }   
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
/**
 * Loads the given website , either directly if the url is a valid WebSite Url or using a SearchEngine like Google
 * 
 * @param webSite
 */
public void loadWebSite(String webSite) {
	
	//Check null or empty
	//		if (webSite == null || webSite.isEmpty())
	//			return;
	
	//Search if it is a valid WebSite url
	String load = !new UrlValidator().isValid(webSite) ? null : webSite;
	
	//Load
	try {
		webEngine.load(
				load != null ? load : getSelectedEngineHomeUrl() + URLEncoder.encode(searchBar.getText(), "UTF-8"));
	} catch (UnsupportedEncodingException ex) {
		ex.printStackTrace();
	}
	
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
/**
 * Validates the input
 * @param object the user to validate
 * @param errors the errors
 */
public void validate(Object object, Errors errors) {

    UserDTO user = (UserDTO) object;

    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "googleId", "field.required",
            "googleId must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "fullName", "field.required",
            "User Full Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "givenName", "field.required",
            "User Given Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "familyName", "field.required",
            "User Family Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "imageURL", "field.required",
            "User Image URL must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "field.required",
            "User Email must not be empty");
    ValidationUtils.rejectIfEmpty(errors, "role", "field.required",
            "User Role must not be empty.");

    // doing specific input validaiton, so we need to make sure all of the fields are there
    if(!errors.hasErrors()) {
        if(user.getRole() < 0 || user.getRole() > 1) {
            errors.rejectValue("role", "field.invalid", "User Role must be 0 or 1");
        }

        if(!EmailValidator.getInstance().isValid(user.getEmail())) {
            errors.rejectValue("email", "field.invalid", "User Email must be a valid email address.");
        }

        if(!UrlValidator.getInstance().isValid(user.getImageURL())) {
            errors.rejectValue("imageURL", "field.invalid", "User Image URl must be a valid web address.");
        }
    }



}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
@Override
public void validate(Object o, Errors errors) {
    UpdateUserDTO user = (UpdateUserDTO) o;

    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userId", "field.required",
            "User Id must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "googleId", "field.required",
            "googleId must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "fullName", "field.required",
            "User Full Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "givenName", "field.required",
            "User Given Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "familyName", "field.required",
            "User Family Name must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "imageURL", "field.required",
            "User Image URL must not be empty.");
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "field.required",
            "User Email must not be empty");
    ValidationUtils.rejectIfEmpty(errors, "role", "field.required",
            "User Role must not be empty.");

    // doing specific input validaiton, so we need to make sure all of the fields are there
    if(!errors.hasErrors()) {
        if(user.getRole() < 0 || user.getRole() > 1) {
            errors.rejectValue("role", "field.invalid", "User Role must be 0 or 1");
        }

        if(!EmailValidator.getInstance().isValid(user.getEmail())) {
            errors.rejectValue("email", "field.invalid", "User Email must be a valid email address.");
        }

        if(!UrlValidator.getInstance().isValid(user.getImageURL())) {
            errors.rejectValue("imageURL", "field.invalid", "User Image URl must be a valid web address.");
        }
    }
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
private void fillTextFieldWithClipboard() {
    String data = "<empty clipboard>";
    try {
        data = (String) Toolkit.getDefaultToolkit().getSystemClipboard().getData(DataFlavor.stringFlavor);
        URL url = new URL(data);
        UrlValidator urlValidator = new UrlValidator();
        if (urlValidator.isValid(data)) {
            textField.setText(url.toString());
            setTextFieldFont(textField.getFont(), TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON);
            textField.setCaretPosition(textField.getText().length());
            textField.selectAll();
            log.debug("Got URL from clipboard: " + url);
        }
    } catch (UnsupportedFlavorException | IllegalStateException | HeadlessException | IOException e) {
        textField.setText("");
        log.warn("Can not read URL from clipboard: [" + data + "]", e);
    }
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
private void onOK() {
    try {
        URL url = new URL(textField.getText());
        UrlValidator urlValidator = new UrlValidator();
        if (urlValidator.isValid(textField.getText())) {
            UrlsProceed.createWebloc(path, url);
            dispose();
        } else {
            throw new MalformedURLException();
        }
    } catch (MalformedURLException e) {
        log.warn("Can not parse URL: [" + textField.getText() + "]", e);

        String message = incorrectUrlMessage + ": [";
        String incorrectUrl = textField.getText()
                .substring(0, Math.min(textField.getText().length(), 10));
        //Fixes EditDialog long url message showing issue
        message += textField.getText().length() > incorrectUrl.length() ? incorrectUrl + "...]" : incorrectUrl + "]";


        UserUtils.showWarningMessageToUser(this, errorTitle,
                message);
    }

}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
public static long getAlignedReadCount(String bam) throws IOException{

		/*  ------------------------------------------------------ */
		/* This chunk prepares SamReader from local bam or URL bam */
		UrlValidator urlValidator = new UrlValidator();
		SamReaderFactory srf=SamReaderFactory.make();
		srf.validationStringency(ValidationStringency.SILENT);
		SamReader samReader;
		if(urlValidator.isValid(bam)){
			samReader = SamReaderFactory.makeDefault().open(
					SamInputResource.of(new URL(bam)).index(new URL(bam + ".bai"))
			);
		} else {
			samReader= srf.open(new File(bam));
		}
		/*  ------------------------------------------------------ */

		List<SAMSequenceRecord> sequences = samReader.getFileHeader().getSequenceDictionary().getSequences();
		long alnCount= 0;
		for(SAMSequenceRecord x : sequences){
			alnCount += samReader.indexing().getIndex().getMetaData(x.getSequenceIndex()).getAlignedRecordCount();
		}
		samReader.close();
		return alnCount;
    }
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
/** Return true if fileName has a valid tabix index. 
 * @throws IOException 
 * */
public static boolean hasTabixIndex(String fileName) throws IOException{
	
	if((new UrlValidator()).isValid(fileName) && fileName.startsWith("ftp")){
		// Because of issue #51
		return false;
	}
	
	try{
		TabixReader tabixReader= new TabixReader(fileName);
		tabixReader.readLine();
		tabixReader.close();
		return true;
	} catch (Exception e){
		return false;
	}
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
public static boolean bamHasIndex(String bam) throws IOException{

		/*  ------------------------------------------------------ */
		/* This chunk prepares SamReader from local bam or URL bam */
		UrlValidator urlValidator = new UrlValidator();
		SamReaderFactory srf=SamReaderFactory.make();
		srf.validationStringency(ValidationStringency.SILENT);
		SamReader samReader;
		if(urlValidator.isValid(bam)){
			samReader = SamReaderFactory.makeDefault().open(
					SamInputResource.of(new URL(bam)).index(new URL(bam + ".bai"))
			);
		} else {
			samReader= srf.open(new File(bam));
		}
		/*  ------------------------------------------------------ */

		// SamReaderFactory srf=SamReaderFactory.make();
		// srf.validationStringency(ValidationStringency.SILENT);
		// SamReader samReader = srf.open(new File(bam));
		boolean hasIndex= samReader.hasIndex();
		samReader.close();
		return hasIndex;
		
	}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
private String removeExternalAnchors(String text) {
    Pattern eanchorPattern = Pattern.compile("\\[.*?\\]");
    Matcher eanchorMatcher = eanchorPattern.matcher(text);

    while (eanchorMatcher.find()) {
        String anchor = eanchorMatcher.group();
        String manchor = anchor.replaceAll("\\[", "");
        manchor = manchor.replaceAll("\\]", "");
        String[] manchorParts = manchor.split("\\s");
        UrlValidator validator = new UrlValidator();
        if (validator.isValid(manchorParts[0])) {
            text = text.replace(anchor, manchor);
        }
    }

    return text;
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
public VirtualNetworkFunctionDescriptor onboardVNFD(byte[] bytes, String projectId)
    throws NotFoundException, PluginException, VimException, IOException, IncompatibleVNFPackage,
        org.openbaton.tosca.exceptions.NotFoundException, BadRequestException,
        AlreadyExistingException, BadFormatException, InterruptedException,
        EntityUnreachableException, ExecutionException {

  InputStream input = new ByteArrayInputStream(bytes);

  readFiles(input);

  VNFDTemplate vnfdt = Utils.bytesToVNFDTemplate(this.template);
  VirtualNetworkFunctionDescriptor vnfd = toscaParser.parseVNFDTemplate(vnfdt);

  String scriptsLink = null;
  UrlValidator urlValidator = new UrlValidator();
  if (urlValidator.isValid(vnfd.getVnfPackageLocation())) {
    scriptsLink = vnfd.getVnfPackageLocation();
  }
  saveVNFD(vnfd, projectId, scripts, scriptsLink);

  input.close();
  this.template.close();
  this.metadata.close();

  return vnfd;
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
private void checkIntegrityVNFPackage(
    VirtualNetworkFunctionDescriptor virtualNetworkFunctionDescriptor) {
  if (virtualNetworkFunctionDescriptor.getVnfPackageLocation() != null) {
    UrlValidator urlValidator = new UrlValidator();
    if (urlValidator.isValid(
        virtualNetworkFunctionDescriptor.getVnfPackageLocation())) { // this is a script link
      VNFPackage vnfPackage = new VNFPackage();
      vnfPackage.setScriptsLink(virtualNetworkFunctionDescriptor.getVnfPackageLocation());
      vnfPackage.setName(virtualNetworkFunctionDescriptor.getName());
      vnfPackage.setProjectId(virtualNetworkFunctionDescriptor.getProjectId());
      if (vnfPackage.getId() == null) vnfPackage = vnfPackageRepository.save(vnfPackage);
      virtualNetworkFunctionDescriptor.setVnfPackageLocation(vnfPackage.getId());
    }
  } else {
    log.warn("vnfPackageLocation is null. Are you sure?");
  }
}
 

import org.apache.commons.validator.routines.UrlValidator; //导入依赖的package包/类
@Test
public void testGetBoards() throws IOException, KomiCrawlerException {
    /**
     * boards.json
     * http://pastebin.com/NLBbVFaX
     */
    KomiCrawler komiCrawler = getCrawler();
    ArrayList<Board> boards = komiCrawler.getBoards();

    Assert.assertTrue("should have boards", boards.size() > 0);
    for (Board board : boards) {
        Assert.assertTrue("should have sid", board.sid instanceof Sid);
        Assert.assertTrue("sid's value should be string", board.sid.getValue().length() > 0);
        Assert.assertTrue("baseUrl should be valid URL", UrlValidator.getInstance().isValid(board.baseUrl));
        Assert.assertTrue("srcBaseUrl should be valid URL", UrlValidator.getInstance().isValid(board.srcBaseUrl));
        Assert.assertTrue("thumbBaseUrl should be valid URL", UrlValidator.getInstance().isValid(board.thumbBaseUrl));
    }
}