package foundation.route;
|
|
import java.net.URLDecoder;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Set;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.util.MapList;
|
import foundation.util.Util;
|
|
|
public class RouteTable {
|
|
protected static Logger logger;
|
private static RouteTable instance;
|
private static String contextPath;
|
private static int contextLength;
|
|
private static HashMap<String, Route> resourceTypeMap;
|
private static URIRouteMap resourceURIMap;
|
private static HashMap<String, Route>virtualPathResourceMap;
|
private static MapList<String, ControllerRoute> controlerMap;
|
private static OperationSet freeCallSet;
|
private static MapList<String, Route> allRouteMap;
|
|
private static AuthorizeURIRoute authorizeURIRoute;
|
private static TimeOutRoute timeOutRoute;
|
private static InvalidUserRightRoute invalidUserRightRoute;
|
private static ServerErrorRoute serverErrorRoute;
|
private static NotExistsRoute notExistsRoute;
|
|
static {
|
logger = LogManager.getLogger(RouteTable.class);
|
}
|
|
|
public static synchronized RouteTable createInstance(String contextPath) {
|
if (instance == null) {
|
instance = new RouteTable(contextPath);
|
}
|
|
return instance;
|
}
|
|
private RouteTable(String context) {
|
init(context);
|
}
|
|
private void init(String context) {
|
//1. context
|
contextPath = context;
|
contextLength = context.length();
|
|
//2.
|
resourceTypeMap = new HashMap<String, Route>();
|
resourceURIMap = new URIRouteMap();
|
virtualPathResourceMap = new HashMap<String, Route>();
|
controlerMap = new MapList<String, ControllerRoute>();
|
freeCallSet = new OperationSet();
|
allRouteMap = new MapList<String, Route>();
|
|
//3.
|
authorizeURIRoute = new AuthorizeURIRoute();
|
timeOutRoute = new TimeOutRoute("root/login.html");
|
invalidUserRightRoute = new InvalidUserRightRoute();
|
serverErrorRoute = new ServerErrorRoute();
|
notExistsRoute = new NotExistsRoute();
|
|
//4.
|
allRouteMap.add("*", authorizeURIRoute);
|
allRouteMap.add("*", timeOutRoute);
|
allRouteMap.add("*", invalidUserRightRoute);
|
allRouteMap.add("*", serverErrorRoute);
|
allRouteMap.add("*", notExistsRoute);
|
}
|
|
public static RouteNavigator matchRoute(HttpServletRequest request) {
|
String uri = request.getRequestURI();
|
|
String path;
|
|
try {
|
path = URLDecoder.decode(uri, "UTF-8");
|
} catch (Exception e) {
|
e.printStackTrace();
|
path = uri;
|
}
|
|
//1. replace root from context path
|
int pos_root = path.lastIndexOf("/root/");
|
path = pos_root >= 0 ? contextPath + path.substring(pos_root + 5) : path;
|
|
//2. delete parameters
|
int pos_end = path.indexOf("?");
|
|
if (pos_end <= 0) {
|
pos_end = path.length();
|
}
|
|
path = path.substring(contextLength, pos_end);
|
|
//3. get suffix
|
int pos_dot = path.lastIndexOf(".");
|
|
String suffix = null;
|
if (pos_dot > 0) {
|
suffix = path.substring(pos_dot);
|
}
|
|
//4. match
|
NavigatorCreator navigatorCreator = new NavigatorCreator(request);
|
doMatchRoute(uri, path, suffix, navigatorCreator);
|
|
return navigatorCreator.getNavigator();
|
}
|
|
private static void doMatchRoute(String uri, String path, String suffix, NavigatorCreator navigatorCreator) {
|
Route route = null;
|
|
//1 resource by suffix
|
if (suffix != null) {
|
suffix = suffix.toLowerCase();
|
route = resourceTypeMap.get(suffix);
|
|
if (route != null) {
|
navigatorCreator.onResourceTypeMatch(uri, path, suffix, route, false);
|
return;
|
}
|
}
|
|
//2 resource by URI
|
String[] segments = createSegements(path);
|
String page = segments[segments.length - 1];
|
route = resourceURIMap.get(page);
|
|
if (route != null) {
|
navigatorCreator.onResourceURIMatch(uri, path, suffix, route, false);
|
return;
|
}
|
|
//3. virtual path resource
|
route = virtualPathResourceMap.get(path);
|
|
if (route != null) {
|
VirtualPathRoute virtualRoute = (VirtualPathRoute) route;
|
navigatorCreator.onVirtualPathMatch(uri, virtualRoute.getTarget(), suffix, route, false);
|
return;
|
}
|
|
//4. controller
|
if (segments.length >= 2) {
|
Operation operation = new Operation(segments);
|
route = controlerMap.get(operation.getObject());
|
|
if (route != null) {
|
boolean authorizeSensitive = !freeCallSet.contains(operation);
|
navigatorCreator.onControllerMatch(uri, path, operation, route, authorizeSensitive);
|
return;
|
}
|
}
|
|
//5. not exists
|
navigatorCreator.onNoMatch(uri, suffix, path);
|
return;
|
}
|
|
private static String[] createSegements(String path) {
|
if (path.charAt(0) == '/') {
|
path = path.substring(1);
|
}
|
|
return path.toLowerCase().split("/");
|
}
|
|
public static void addFreeVisitResourceType(String type) {
|
if (Util.isEmpty(type)) {
|
return;
|
}
|
|
Route route = new FreeTypeRoute(type);
|
String from = route.getFrom();
|
|
resourceTypeMap.put(from, route);
|
allRouteMap.add(type, route);
|
}
|
|
public static void appendFreeVisitResource(String uri) {
|
if (Util.isEmpty(uri)) {
|
return;
|
}
|
|
Route route = new FreeURIRoute(uri);
|
String from = route.getFrom();
|
|
resourceURIMap.add(from, route);
|
allRouteMap.add(uri, route);
|
}
|
|
public static void appendVirtualPath(String from, String target) {
|
VirtualPathRoute route = new VirtualPathRoute(from, target);
|
|
virtualPathResourceMap.put(from, route);
|
allRouteMap.add(from, route);
|
}
|
|
public static void appendFreeVisitCall(String call) {
|
if (Util.isEmpty(call)) {
|
return;
|
}
|
|
call = call.toLowerCase();
|
freeCallSet.add(call);
|
}
|
|
public static void appendCallableClass(String path, String classname) throws Exception {
|
try {
|
ControllerRoute route = new ControllerRoute(path, classname);
|
String from = route.getFrom();
|
|
controlerMap.add(from, route);
|
allRouteMap.add(path, route);
|
|
}
|
catch (ClassNotFoundException e) {
|
e.printStackTrace();
|
}
|
}
|
|
public static List<Route> getRouteList() {
|
return allRouteMap.getItemList();
|
}
|
|
public static List<Route> getFreeResourceTypeRouteList() {
|
List<Route> result = new ArrayList<Route>();
|
|
Set<String> keys = resourceTypeMap.keySet();
|
for (String key: keys) {
|
result.add(resourceTypeMap.get(key));
|
}
|
|
return result;
|
}
|
|
public static List<Route> getFreeResourceURIRouteList() {
|
List<Route> result = new ArrayList<Route>();
|
|
Set<String> keys = resourceURIMap.keySet();
|
for (String key: keys) {
|
result.add(resourceURIMap.get(key));
|
}
|
|
return result;
|
}
|
|
public static List<Route> getAuthorizedControlerRouteList() {
|
List<Route> result = new ArrayList<Route>();
|
|
Set<String> keys = controlerMap.keySet();
|
for (String key: keys) {
|
result.add(controlerMap.get(key));
|
}
|
|
return result;
|
}
|
|
public static List<Route> getSpecializedRouteList() {
|
List<Route> result = new ArrayList<Route>();
|
|
result.add(authorizeURIRoute);
|
result.add(invalidUserRightRoute);
|
result.add(timeOutRoute);
|
result.add(serverErrorRoute);
|
result.add(notExistsRoute);
|
|
return result;
|
}
|
|
public static List<ControllerRoute> getControlerList() {
|
return controlerMap.getItemList();
|
}
|
|
public static ControllerRoute getControler(String name) {
|
return controlerMap.get(name);
|
}
|
|
public static Route getTimeOutRoute() {
|
return timeOutRoute;
|
}
|
|
public static Route getNotExistsRoute() {
|
return notExistsRoute;
|
}
|
|
public static ServerErrorRoute getServerErrorRoute() {
|
return serverErrorRoute;
|
}
|
|
public static InvalidUserRightRoute getInvalidUserRightRoute() {
|
return invalidUserRightRoute;
|
}
|
|
}
|
