Java Template类代码示例

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public Restlet createInboundRoot() {
	Router baseRouter = new Router(context);
	baseRouter.setDefaultMatchingMode(Template.MODE_STARTS_WITH);
	for (RestletRoutable rr : restlets) {
		baseRouter.attach(rr.basePath(), rr.getRestlet(context));
	}

	Filter slashFilter = new Filter() {            
		@Override
		protected int beforeHandle(Request request, Response response) {
			Reference ref = request.getResourceRef();
			String originalPath = ref.getPath();
			if (originalPath.contains("//"))
			{
				String newPath = originalPath.replaceAll("/+", "/");
				ref.setPath(newPath);
			}
			return Filter.CONTINUE;
		}

	};
	slashFilter.setNext(baseRouter);

	return slashFilter;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public Restlet createInboundRoot() {
    Router baseRouter = new Router(context);
    baseRouter.setDefaultMatchingMode(Template.MODE_STARTS_WITH);
    for (RestletRoutable rr : restlets) {
        baseRouter.attach(rr.basePath(), rr.getRestlet(context));
    }

    Filter slashFilter = new Filter() {            
        @Override
        protected int beforeHandle(Request request, Response response) {
            Reference ref = request.getResourceRef();
            String originalPath = ref.getPath();
            if (originalPath.contains("//"))
            {
                String newPath = originalPath.replaceAll("/+", "/");
                ref.setPath(newPath);
            }
            return Filter.CONTINUE;
        }

    };
    slashFilter.setNext(baseRouter);
    
    return slashFilter;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
/**
 * Handles the call after resolving any URI template on the request's target
 * resource reference.
 * 
 * @param request
 *            The request to handle.
 * @param response
 *            The response to update.
 */
public int beforeHandle(Request request, Response response) {
    // Associate the response to the current thread
    Protocol protocol = request.getProtocol();

    if (protocol == null) {
        throw new UnsupportedOperationException(
                "Unable to determine the protocol to use for this call.");
    }

    String targetUri = request.getResourceRef().toString(true, false);

    if (targetUri.contains("{")) {
        // Template URI detected, create the template
        Template template = new Template(targetUri);

        // Set the formatted target URI
        request.setResourceRef(template.format(request, response));
    }

    request.setOriginalRef(ReferenceUtils.getOriginalRef(request.getResourceRef(), request.getHeaders()));
    return CONTINUE;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
/**
 * Starts the log service by attempting to read the log properties if the
 * {@link #getLogPropertiesRef()} returns a non null URI reference.
 */
@Override
public synchronized void start() throws Exception {
    super.start();

    this.responseLogTemplate = (getResponseLogFormat() == null) ? null
            : new Template(getResponseLogFormat());
    if (getLogPropertiesRef() != null) {
        Representation logProperties = new ClientResource(getContext(),
                getLogPropertiesRef()).get();

        if (logProperties != null) {
            java.util.logging.LogManager.getLogManager().readConfiguration(
                    logProperties.getStream());
        }
    }
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public synchronized Restlet createInboundRoot() {
    seqNo = SEQNO_PREFIX + mf.getNoToString();
    logger.info(seqNo + "\t" + "createInboundRoot() Start");
    Router router = new Router(getContext());

    router.attach(CST_PATH, ComponentManagerStarter.class);
    router.attach(NWCST_PATH, NWCStarter.class);
    router.attach(LGCST_PATH, LGCStarter.class);
    router.attach(CONNECTION_PATH, ConnectionCreator.class);
    router.attach(GUI_PATH, GUIRestApi.class);
    router.attach(ROUTER_PATH, RMNodeRestApi.class);
    router.attach(LAYERIZER_PATH, RMLinkLayerizerRestApi.class, Template.MODE_STARTS_WITH);

    logger.info(seqNo + "\t" + "createInboundRoot() End");
    return router;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
/**
 * Redirects a URI to a new URI. You can use template variables in the URIs.
 * <p>
 * Enforces matching mode {@link Template#MODE_EQUALS}.
 * <p>
 * This is handled via a {@link NormalizingRedirector}.
 * 
 * @param uriTemplate
 *        The URI path template that must match the relative part of the
 *        resource URI
 * @param targetUriTemplate
 *        The target URI template
 * @param statusCode
 *        HTTP status code (must be 301, 302, 303 or 307)
 * @return The created route
 * @see NormalizingRedirector
 */
public TemplateRoute redirectClient( String uriTemplate, String targetUriTemplate, int statusCode )
{
	int mode;
	switch( statusCode )
	{
		case 301:
			mode = Redirector.MODE_CLIENT_PERMANENT;
			break;
		case 302:
			mode = Redirector.MODE_CLIENT_FOUND;
			break;
		case 303:
			mode = Redirector.MODE_CLIENT_SEE_OTHER;
			break;
		case 307:
			mode = Redirector.MODE_CLIENT_TEMPORARY;
			break;
		default:
			throw new IllegalArgumentException( "Unsupported status code: " + statusCode );
	}

	TemplateRoute route = attach( uriTemplate, new NormalizingRedirector( getContext(), targetUriTemplate, mode ) );
	route.setMatchingMode( Template.MODE_EQUALS );
	return route;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public void handle( Request request, Response response )
{
	// RIAP ignores hide
	if( request.getProtocol() != Protocol.RIAP )
	{
		String remainingPart = request.getResourceRef().getRemainingPart();
		for( Template hiddenUriTemplate : hiddenUriTemplates )
		{
			if( hiddenUriTemplate.match( remainingPart ) != -1 )
			{
				response.setStatus( Status.CLIENT_ERROR_NOT_FOUND );
				return;
			}
		}
	}

	super.handle( request, response );
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
protected Reference getTargetRef( Request request, Response response )
{
	// This is essentially the original Restlet code modified to use
	// ResolvingTemplate.

	// Create the template
	Template rt = new ResolvingTemplate( this.targetTemplate );
	rt.setLogger( getLogger() );

	// Return the formatted target URI
	if( new Reference( this.targetTemplate ).isRelative() )
		// Be sure to keep the resource's base reference.
		return new Reference( request.getResourceRef(), rt.format( request, response ) );

	return new Reference( rt.format( request, response ) );
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
    public Restlet createInboundRoot() {
        // Create a router
        Router router = new Router(getContext());

        // Attach the resources to the router
        adminGuard = getAdminGuard();
        adminGuard.setNext(AdminResource.class);
        router.attach("/admin/{ares}/{idr}", adminGuard, Template.MODE_STARTS_WITH);
        router.attach("/admin/{ares}", adminGuard, Template.MODE_STARTS_WITH);
        router.attach("/admin", adminGuard, Template.MODE_STARTS_WITH);
//        Directory directory = new Directory(getContext(),getDocumentRoot());
//        directory.setIndexName("index.html");
        router.attach("/js", new Directory(getContext(),"file:///"+getDocumentRoot()+"/js"));
        router.attach("/css", new Directory(getContext(),"file:///"+getDocumentRoot()+"/css"));

        userGuard = getUserGuard();
        userGuard.setNext(PrintResource.class);
        router.attach("/print/", userGuard);
        router.attach("/", RootResource.class);
        
        
        // Return the root router
        return router;
    }
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public Restlet createInboundRoot() {
	// encoding service that allows disabling
	setEncoderService(new OntopiaEncoderService());
	
	Router versions = new Router(getContext());
	versions.setDefaultMatchingMode(Template.MODE_STARTS_WITH);
	versions.setRoutingMode(Router.MODE_BEST_MATCH);
	versions.setName("Ontopia API root router");
	
	versions.attach("/", APIInfoResource.class);
	
	for (APIVersions version : APIVersions.values()) {
		if (isEnabled(version)) {
			logger.info("Exposing API {}", version.getName());
			versions.attach("/" + version.getName(), new OntopiaAPIVersionFilter(getContext(), version.createChain(this), version));
		}
	}

	return versions;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
/** Creates a new instance of ConfiguredHost */
public ConfiguredHost(Context context,Configuration.Server server,Configuration.Host hostConf)
{
   this.context = context;
   this.server = server;
   this.hostConf = hostConf;
   this.router = new Router(context);
   this.router.setDefaultMatchingMode(Template.MODE_STARTS_WITH);
   hostConf.attach(router);
   if (hostConf.getLogConfiguration().get("pattern")!=null) {
      String name = hostConf.getName();
      if (name.equals("*")) {
         name = "any";
      }
      name = "host."+name;
      this.hostLog = Logger.getLogger(name);
      setupLog();
   }
   this.defaultVHost = getVirtualHost(hostConf.getName());
   
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
public Restlet createInboundRoot() {
   String viewValue = getContext().getParameters().getFirstValue("login.view");
   boolean viewEnabled = viewValue==null || "true".equals(viewValue.trim());
   
   Router router = new Router(getContext());
   if (viewEnabled) {
      getLogger().info("Enabling view on login.");
      router.attach("/",LoginView.class);
      router.attach("/js/",new ClassResourceFinder(getContext(),LoginApplication.class,"js")).getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);
      router.attach("/logout",LogoutView.class);
   }  
   router.attach("/auth",LoginAction.class);
   router.attach("/status/check",CheckAction.class);
   router.attach("/status",StatusAction.class);
   router.attach("/expire",LogoutAction.class);
   return router;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
@Override
public Restlet createInboundRoot() {
    Router baseRouter = new Router(context);
    baseRouter.setDefaultMatchingMode(Template.MODE_STARTS_WITH);
    for (RestletRoutable rr : restlets) {
        baseRouter.attach(rr.basePath(), rr.getRestlet(context));
    }

    Filter slashFilter = new Filter() {
        @Override
        protected int beforeHandle(Request request, Response response) {
            Reference ref = request.getResourceRef();
            String originalPath = ref.getPath();
            if (originalPath.contains("//")) {
                String newPath = originalPath.replaceAll("/+", "/");
                ref.setPath(newPath);
            }
            return Filter.CONTINUE;
        }

    };
    slashFilter.setNext(baseRouter);

    return slashFilter;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
protected TemplateRoute attach(Router router, Class<?> targetClass) {
    TemplateRoute route = null;
    Resource resource = AnnotationUtils.findAnnotation(targetClass, Resource.class);
    if (resource != null) {
        route = router.attach(resource.path(), new ServerResourceInjectedFinder(getContext(), targetClass));
        if (resource.strict()) {
            route.getTemplate().setMatchingMode(Template.MODE_EQUALS);
        } else {
            route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);
        }
    } else {
        throw new RuntimeException("Resource " + targetClass + " require @Resouce annotation.");
    }

    return route;
}
 

import org.restlet.routing.Template; //导入依赖的package包/类
/**
 * 
 * @param router
 * @param strict
 *            The matching mode to use when parsing a formatted reference.
 * @param uriPattern
 * @param target
 * @return
 */
@Override
public TemplateRoute attach(Router router, boolean strict, String uriPattern, Restlet target) {
	if (logger.isDebugEnabled()) {
		logger.debug("Attaching Restlet of class '" + target.getClass().getName() + "' to URI='" + uriPattern
				+ "' (strict='" + strict + "')");
	}

	TemplateRoute route = router.attach(uriPattern, target);

	if (strict) {
		route.getTemplate().setMatchingMode(Template.MODE_EQUALS);
	} else {
		route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);
	}
	return route;
}