Java Conf类代码示例

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected static List<OutboundRule> getSupportedOutboundRules(String urlConfPath, Conf conf) {
    List<OutboundRule> filteredRules = new ArrayList<>();
    for (Object outboundRuleObj : conf.getOutboundRules()) {
        final OutboundRule outboundRule = (OutboundRule) outboundRuleObj;
        String matchType = outboundRule.getMatchType();
        if (matchType != null && !matchType.isEmpty() && !"regex".equals(matchType)) {
            Debug.logWarning("urlrewrite: outbound-rule in " + urlConfPath + " uses unsupported match-type: " + matchType + "; ignoring rule", module);
            continue;
        }
        if (UtilValidate.isEmpty(outboundRule.getFrom()) || outboundRule.getTo() == null) {
            Debug.logWarning("urlrewrite: outbound-rule in " + urlConfPath + " omits 'from' or 'to' elements; unsupported; ignoring rule", module);
            continue;
        }
        if (UtilValidate.isNotEmpty(outboundRule.getConditions())) {
            Debug.logWarning("urlrewrite: outbound-rule in " + urlConfPath + " has condition elements; unsupported; ignoring rule", module);
            continue;
        }
        filteredRules.add(outboundRule);
    }
    return filteredRules;
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
private void processRewriteEngine(Conf conf, String line) {
    boolean enabled = true;
    Matcher engineMatcher = ENGINE_PATTERN.matcher(line);
    if (engineMatcher.matches()) {
        String enabledStr = StringUtils.trim(engineMatcher.group(1));
        log.debug("RewriteEngine value parsed as '" + enabledStr + "'");
        if ("0".equalsIgnoreCase(enabledStr) ||
                "false".equalsIgnoreCase(enabledStr) ||
                "no".equalsIgnoreCase(enabledStr) ||
                "off".equalsIgnoreCase(enabledStr)) enabled = false;
        log.debug("RewriteEngine as boolean '" + enabled + "'");
    } else {
        log.error("cannot parse " + line);
    }
    conf.setEngineEnabled(enabled);
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
@Override
protected void loadUrlRewriter(FilterConfig filterConfig) throws ServletException {
    try {
        Conf conf = new Conf(filterConfig.getServletContext(), resource.getInputStream(), resource.getFilename(), "");
    checkConf(conf);
    } catch (IOException ex) {
        throw new ServletException("Unable to load URL-rewrite configuration file from " + CONFIG_LOCATION, ex);
    }
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public static UrlRewriteConf loadConf(String urlConfPath) throws IOException {
    if (Debug.verboseOn()) {
        Debug.logVerbose("urlrewrite: loading " + urlConfPath, module);
    }
    // load config
    URL confUrl;
    InputStream inputStream = null;
    
    confUrl = FlexibleLocation.resolveLocation(urlConfPath);

    try {
        inputStream = confUrl.openStream();
        // attempt to retrieve from location other than local WEB-INF

        if (inputStream == null) {
            throw new IOException("Unable to find urlrewrite conf file at: " + urlConfPath);
        } else {
            Conf conf = new Conf(null, inputStream, urlConfPath, confUrl.toString(), false);
            
            return new UrlRewriteConf(urlConfPath, conf);
        }
    } finally {
        try {
            if (inputStream != null) inputStream.close();
        } catch (IOException e) {
        }
    }

}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void process(InputStream is, Conf conf) throws IOException {
    String line;
    BufferedReader in = new BufferedReader(new InputStreamReader(is));
    StringBuffer buffer = new StringBuffer();
    while ((line = in.readLine()) != null) {
        buffer.append(line);
        buffer.append("\n");
    }
    process(buffer.toString(), conf);
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
private void parseRule(Conf conf, List conditionsBuffer, StringBuffer notesBuffer, String line) {
    NormalRule rule = processRule(line);
    for (int j = 0; j < conditionsBuffer.size(); j++) {
        Condition condition = (Condition) conditionsBuffer.get(j);
        rule.addCondition(condition);
    }
    if (notesBuffer.length() > 0) rule.setNote(notesBuffer.toString());
    conf.addRule(rule);
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void loadUrlRewriter(FilterConfig filterConfig) throws ServletException {
    // add configurations
    try {
        Conf conf1 = new Conf(filterConfig.getServletContext(), new FileInputStream("someconf.xml"), "someconf.xml", "");
        urlrewriters.add(new UrlRewriter(conf1));

        Conf conf2 = new SampleConfExt();
        urlrewriters.add(new UrlRewriter(conf2));

    } catch (Exception e) {
        throw new ServletException(e);
    }
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void testLoadFromFile2() throws IOException {
    InputStream is = ModRewriteConfLoaderTest.class.getResourceAsStream(BASE_PATH + "htaccess-test1.txt");
    Conf conf = new Conf(null, is, "htaccess-test1.txt", null, true);
    assertTrue(conf.isEngineEnabled());
    assertTrue(conf.isOk());
    assertEquals(1, conf.getRules().size());
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
@Override
protected void loadUrlRewriter(FilterConfig filterConfig) throws ServletException {
    String confPath = filterConfig.getInitParameter("confPath");
    ServletContext context = filterConfig.getServletContext();
    try {
        final URL confUrl = getClass().getClassLoader().getResource(confPath);
        final InputStream config = getClass().getClassLoader().getResourceAsStream(confPath);
        Conf conf = new Conf(context, config, confPath, confUrl.toString(), false);
        checkConf(conf);
    } catch (Throwable e) {
        throw new ServletException(e);
    }
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
protected UrlRewriteConf(String urlConfPath, Conf conf) throws IOException {
    this.urlConfPath = urlConfPath;
    this.conf = conf;
    this.supportedOutboundRules = getSupportedOutboundRules(urlConfPath, conf);
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public Conf getConf() {
    return conf;
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void setConf(Conf conf) {
    this.conf = conf;
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void setUp() {
    Log.setLevel("DEBUG");
    conf = new Conf();
}
 

import org.tuckey.web.filters.urlrewrite.Conf; //导入依赖的package包/类
public void loadConf(URL confFileUrl) {
    Log.setLevel("SYSOUT:DEBUG");
    conf = new Conf(confFileUrl);
    assertTrue("Conf should load without errors", conf.isOk());
    urlRewriter = new UrlRewriter(conf);
}