hybridurlcodingstrategy.java

Wicket一个开发Java Web应用程序框架。它使得开发web应用程序变得容易而轻松。 Wicket利用一个POJO data beans组件使得它可以与任何持久层技术相结合。

			return target.getPage().getClass().equals(pageClassRef.get()) &&
				target.getRequestListenerInterface().equals(IRedirectListener.INTERFACE);
		}
		return false;
	}

	/**
	 * Class that encapsulates {@link PageInfo} instance and the URL part prior the PageInfo part
	 * 
	 * @author Matej Knopp
	 */
	protected static class PageInfoExtraction
	{
		private final String urlAfterExtraction;

		private final PageInfo pageInfo;

		/**
		 * Construct.
		 * 
		 * @param urlAfterExtraction
		 * @param pageInfo
		 */
		public PageInfoExtraction(String urlAfterExtraction, PageInfo pageInfo)
		{
			this.urlAfterExtraction = urlAfterExtraction;
			this.pageInfo = pageInfo;
		}

		/**
		 * @return
		 */
		public PageInfo getPageInfo()
		{
			return pageInfo;
		}

		/**
		 * @return
		 */
		public String getUrlAfterExtraction()
		{
			return urlAfterExtraction;
		}
	}

	/**
	 * Extracts the PageInfo string.
	 * 
	 * @param url
	 * @return
	 */
	protected PageInfoExtraction extractPageInfo(String url)
	{
		int begin = url.lastIndexOf(getBeginSeparator());
		PageInfo last = null;
		String lastSubstring = "";
		while (begin != -1)
		{
			String substring = url.substring(begin);
			if (substring.length() > getBeginSeparator().length() + getEndSeparator().length() &&
				substring.startsWith(getBeginSeparator()) && substring.endsWith(getEndSeparator()))
			{
				String pageInfoString = substring.substring(getBeginSeparator().length(), //
					substring.length() - getEndSeparator().length());
				PageInfo info = PageInfo.parsePageInfo(pageInfoString);
				if (info != null)
				{
					last = info;
					lastSubstring = substring;
				}
				else
				{
					break;
				}
			}
			begin = url.lastIndexOf(getBeginSeparator(), begin - 1);
		}
		if (last != null)
		{
			return new PageInfoExtraction(url.substring(0, url.length() - lastSubstring.length()),
				last);
		}
		else
		{
			return new PageInfoExtraction(url, null);
		}
	}

	protected String getBeginSeparator()
	{
		return ".";
	}

	protected String getEndSeparator()
	{
		return "";
	}

	/**
	 * Encodes the PageInfo part to the URL
	 * 
	 * @param url
	 * @param pageInfo
	 * @return
	 */
	protected String addPageInfo(String url, PageInfo pageInfo)
	{
		if (pageInfo != null)
		{
			return url + getBeginSeparator() + pageInfo.toString() + getEndSeparator();
		}
		else
		{
			return url;
		}
	}

	/**
	 * Possible string representation of PageInfo:
	 * <ul>
	 * <li>pageId
	 * <li>pageId.version
	 * <li>pageMap (only if pageMap starts with a letter)
	 * <li>.pageMap
	 * <li>pageMap.pageId.version
	 * <li>pageMap.pageId (only if pageMap name starts with a letter)
	 * </ul>
	 * 
	 * @author Matej Knopp
	 */
	protected static class PageInfo
	{
		private final Integer pageId;
		private final Integer versionNumber;
		private final String pageMapName;

		/**
		 * Construct.
		 * 
		 * @param pageId
		 * @param versionNumber
		 * @param pageMapName
		 */
		public PageInfo(Integer pageId, Integer versionNumber, String pageMapName)
		{
			if ((pageId == null && (versionNumber != null || pageMapName == null)) ||
				(versionNumber == null && (pageId != null || pageMapName == null)))
			{
				throw new IllegalArgumentException(
					"Either both pageId and versionNumber must be null or none of them.");
			}
			this.pageId = pageId;
			this.versionNumber = versionNumber;
			this.pageMapName = pageMapName;
		}

		/**
		 * @return
		 */
		public Integer getPageId()
		{
			return pageId;
		}

		/**
		 * @return
		 */
		public Integer getVersionNumber()
		{
			return versionNumber;
		}

		/**
		 * @return
		 */
		public String getPageMapName()
		{
			return pageMapName;
		}

		private static char getPageInfoSeparator()
		{
			return '.';
		}

		/**
		 * <ul>
		 * <li>pageId
		 * <li>pageId.version
		 * <li>pageMap (only in if pagemap starts with a letter)
		 * <li>.pageMap
		 * <li>pageMap.pageId (only in if pageMap name starts with a letter)
		 * <li>pageMap.pageId.version
		 * </ul>
		 */
		public String toString()
		{
			String pageMapName = this.pageMapName;

			// we don't need to encode the pageMapName when the pageId is unique
			// per session
			if (pageMapName != null && pageId != null && Application.exists() &&
				Application.get().getSessionSettings().isPageIdUniquePerSession())
			{
				pageMapName = null;
			}

			AppendingStringBuffer buffer = new AppendingStringBuffer(5);

			final boolean pmEmpty = Strings.isEmpty(pageMapName);
			final boolean pmContainsLetter = !pmEmpty && !isNumber(pageMapName);


			if (pageId != null && pmEmpty && versionNumber.intValue() == 0)
			{
				// pageId
				buffer.append(pageId);
			}
			else if (pageId != null && pmEmpty && versionNumber.intValue() != 0)
			{
				// pageId.version
				buffer.append(pageId);
				buffer.append(getPageInfoSeparator());
				buffer.append(versionNumber);
			}
			else if (pageId == null && pmContainsLetter)
			{
				// pageMap (must start with letter)
				buffer.append(pageMapName);
			}
			else if (pageId == null && !pmEmpty && !pmContainsLetter)
			{
				// .pageMap
				buffer.append(getPageInfoSeparator());
				buffer.append(pageMapName);
			}
			else if (pmContainsLetter && pageId != null && versionNumber.intValue() == 0)
			{
				// pageMap.pageId (pageMap must start with a letter)
				buffer.append(pageMapName);
				buffer.append(getPageInfoSeparator());
				buffer.append(pageId);
			}
			else if (!pmEmpty && pageId != null)
			{
				// pageMap.pageId.pageVersion
				buffer.append(pageMapName);
				buffer.append(getPageInfoSeparator());
				buffer.append(pageId);
				buffer.append(getPageInfoSeparator());
				buffer.append(versionNumber);
			}

			return buffer.toString();
		}

		/**
		 * Method that rigidly checks if the string consists of digits only.
		 * 
		 * @param string
		 * @return
		 */
		private static boolean isNumber(String string)
		{
			if (string == null || string.length() == 0)
			{
				return false;
			}
			for (int i = 0; i < string.length(); ++i)
			{
				if (Character.isDigit(string.charAt(i)) == false)
				{
					return false;
				}
			}
			return true;
		}

		/**
		 * <ul>
		 * <li>pageId
		 * <li>pageId.version
		 * <li>pageMap (only in if pagemap starts with a letter)
		 * <li>.pageMap
		 * <li>pageMap.pageId (only in if pageMap name starts with a letter)
		 * <li>pageMap.pageId.version
		 * </ul>
		 * 
		 * @param src
		 * @return
		 */
		public static PageInfo parsePageInfo(String src)
		{
			if (src == null || src.length() == 0)
			{
				return null;
			}

			String segments[] = Strings.split(src, getPageInfoSeparator());

			if (segments.length > 3)
			{
				return null;
			}

			// go trhough the segments to determine if they don't contains invalid characters
			for (int i = 0; i < segments.length; ++i)
			{
				for (int j = 0; j < segments[i].length(); ++j)
				{
					char c = segments[i].charAt(j);
					if (!Character.isLetterOrDigit(c) && c != '-' && c != '_')
					{
						return null;
					}
				}
			}

			if (segments.length == 1 && isNumber(segments[0]))
			{
				// pageId
				return new PageInfo(Integer.valueOf(segments[0]), new Integer(0), null);
			}
			else if (segments.length == 2 && isNumber(segments[0]) && isNumber(segments[1]))
			{
				// pageId:pageVersion
				return new PageInfo(Integer.valueOf(segments[0]), Integer.valueOf(segments[1]),
					null);
			}
			else if (segments.length == 1 && !isNumber(segments[0]))
			{
				// pageMap (starts with letter)
				return new PageInfo(null, null, segments[0]);
			}
			else if (segments.length == 2 && segments[0].length() == 0)
			{
				// .pageMap
				return new PageInfo(null, null, segments[1]);
			}
			else if (segments.length == 2 && !isNumber(segments[0]) && isNumber(segments[1]))
			{
				// pageMap.pageId (pageMap starts with letter)
				return new PageInfo(Integer.valueOf(segments[1]), new Integer(0), segments[0]);
			}
			else if (segments.length == 3)
			{
				if (segments[2].length() == 0 && isNumber(segments[1]))
				{
					// we don't encode it like this, but we still should be able
					// to parse it
					// pageMapName.pageId.
					return new PageInfo(Integer.valueOf(segments[1]), new Integer(0), segments[0]);
				}
				else if (isNumber(segments[1]) && isNumber(segments[2]))
				{
					// pageMapName.pageId.pageVersion
					return new PageInfo(Integer.valueOf(segments[1]), Integer.valueOf(segments[2]),
						segments[0]);
				}
			}

			return null;
		}

	};

	/**
	 * BookmarkablePage request target that does a redirect after bookmarkable page was rendered
	 * (only if the bookmarkable page is stateful though)
	 * 
	 * @author Matej Knopp
	 */
	public static class HybridBookmarkablePageRequestTarget extends BookmarkablePageRequestTarget
	{
		private final int originalUrlTrailingSlashesCount;
		private final boolean redirect;

		/**
		 * Construct.
		 * 
		 * @param pageMapName
		 * @param pageClass
		 * @param pageParameters
		 * @param originalUrlTrailingSlashesCount
		 * @param redirect
		 */
		public HybridBookmarkablePageRequestTarget(String pageMapName, Class pageClass,
			PageParameters pageParameters, int originalUrlTrailingSlashesCount, boolean redirect)
		{
			super(pageMapName, pageClass, pageParameters);
			this.originalUrlTrailingSlashesCount = originalUrlTrailingSlashesCount;
			this.redirect = redirect;
		}

		protected Page newPage(Class pageClass, RequestCycle requestCycle)
		{
			Page page = super.newPage(pageClass, requestCycle);
			page.setMetaData(PAGE_PARAMETERS_META_DATA_KEY, getPageParameters());
			page.setMetaData(ORIGINAL_TRAILING_SLASHES_COUNT_METADATA_KEY, new Integer(
				originalUrlTrailingSlashesCount));
			return page;
		}

		public void respond(RequestCycle requestCycle)
		{
			Page page = getPage(requestCycle);
			if (page.isPageStateless() == false && redirect)
			{
				requestCycle.redirectTo(page);
			}
			else
			{
				super.respond(requestCycle);
			}
		}
	};

	/**
	 * @see org.apache.wicket.request.target.coding.AbstractRequestTargetUrlCodingStrategy#matches(java.lang.String)
	 */
	public boolean matches(String path)
	{
		RequestCycle rc = RequestCycle.get();

		// the null check is necessary, as this method is first time called from WicketFilter when
		// no RequestCycle exists yet
		if (rc != null && ((WebRequest)rc.getRequest()).isAjax())
		{
			// HybridUrlCodingStrategy doesn't make sense for ajax request
			return false;
		}

		if (path.startsWith(getMountPath()))
		{
			/*
			 * We need to match /mount/point or /mount/point/with/extra/path, but not
			 * /mount/pointXXX
			 */
			String remainder = path.substring(getMountPath().length());
			if (remainder.length() == 0 || remainder.startsWith("/"))
			{
				return true;
			}
			/*
			 * We also need to accept /mount/point(XXX)
			 */
			if (remainder.length() > getBeginSeparator().length() + getEndSeparator().length() &&
				remainder.startsWith(getBeginSeparator()) && remainder.endsWith(getEndSeparator()))
			{
				String substring = remainder.substring(getBeginSeparator().length(), //
					remainder.length() - getEndSeparator().length());
				PageInfo info = PageInfo.parsePageInfo(substring);
				if (info != null)
				{
					return true;
				}
			}
		}
		return false;
	}

	public String toString()
	{
		return "HybridUrlCodingStrategy[page=" + pageClassRef.get() + "]";
	}

}