com.blade.Blade Java Examples

@Override
public void preHandle(Blade blade) {
    Ioc ioc = blade.ioc();

    boolean devMode = true;
    if (blade.environment().hasKey("app.dev")) {
        devMode = blade.environment().getBoolean("app.dev", true);
    }
    if (blade.environment().hasKey("app.devMode")) {
        devMode = blade.environment().getBoolean("app.devMode", true);
    }
    SqliteJdbc.importSql(devMode);

    Sql2o sql2o = new Sql2o(SqliteJdbc.DB_SRC, null, null);
    Base.open(sql2o);
    Commons.setSiteService(ioc.getBean(SiteService.class));
}
 

public static void main(String[] args) {

        Blade.of()
            .get("/", ctx -> ctx.render("index.html"))
            .get("/basic-route-example", ctx -> ctx.text("GET called"))
            .post("/basic-route-example", ctx -> ctx.text("POST called"))
            .put("/basic-route-example", ctx -> ctx.text("PUT called"))
            .delete("/basic-route-example", ctx -> ctx.text("DELETE called"))
            .addStatics("/custom-static")
            // .showFileList(true)
            .enableCors(true)
            .before("/user/*", ctx -> log.info("[NarrowedHook] Before '/user/*', URL called: " + ctx.uri()))
            .on(EventType.SERVER_STARTED, e -> {
                String version = WebContext.blade()
                    .env("app.version")
                    .orElse("N/D");
                log.info("[Event::serverStarted] Loading 'app.version' from configuration, value: " + version);
            })
            .on(EventType.SESSION_CREATED, e -> {
                Session session = (Session) e.attribute("session");
                session.attribute("mySessionValue", "Baeldung");
            })
            .use(new BaeldungMiddleware())
            .start(App.class, args);
    }
 

@GetRoute(value = "")
public String index(Request request) {
    // 读取主题
    String         themesDir  = AttachController.CLASSPATH + "templates/themes";
    File[]         themesFile = new File(themesDir).listFiles();
    List<ThemeDto> themes     = new ArrayList<>(themesFile.length);
    for (File f : themesFile) {
        if (f.isDirectory()) {
            ThemeDto themeDto = new ThemeDto(f.getName());
            if (Files.exists(Paths.get(f.getPath() + "/setting.html"))) {
                themeDto.setHasSetting(true);
            }
            themes.add(themeDto);
            try {
                Blade.me().addStatics("/templates/themes/" + f.getName() + "/screenshot.png");
            } catch (Exception e) {
            }
        }
    }
    request.attribute("current_theme", Commons.site_theme());
    request.attribute("themes", themes);
    return "admin/themes";
}
 

@Override
protected Statement withBeforeClasses(final Statement statement) {
    final Statement junitStatement = super.withBeforeClasses(statement);
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            blade = Blade.me().start(mainCls).await();
            junitStatement.evaluate();
        }
    };
}
 

@Override
public void load(Blade blade) {
    String version = WebContext.blade()
        .env("app.version")
        .orElse("N/D");
    String authors = WebContext.blade()
        .env("app.authors", "Unknown authors");

    log.info("[LoadConfig] loaded 'app.version' (" + version + ") and 'app.authors' (" + authors + ") in a configuration bean");
}
 

@Override
public void load(Blade blade) {
    try {
        JetbrickTemplateEngine templateEngine = new JetbrickTemplateEngine();
        blade.templateEngine(templateEngine);

        HikariConfig config = new HikariConfig();

        String url                   = blade.env("jdbc.url", "");
        String username              = blade.env("jdbc.username", "");
        String password              = blade.env("jdbc.password", "");
        String cachePrepStmts        = blade.env("datasource.cachePrepStmts", "true");
        String prepStmtCacheSize     = blade.env("datasource.prepStmtCacheSize", "250");
        String prepStmtCacheSqlLimit = blade.env("datasource.prepStmtCacheSqlLimit", "2048");

        config.setJdbcUrl(url);
        config.setUsername(username);
        config.setPassword(password);
        config.addDataSourceProperty("cachePrepStmts", cachePrepStmts);
        config.addDataSourceProperty("prepStmtCacheSize", prepStmtCacheSize);
        config.addDataSourceProperty("prepStmtCacheSqlLimit", prepStmtCacheSqlLimit);

        HikariDataSource ds = new HikariDataSource(config);
        Anima.open(ds);
    } catch (Exception e) {
        System.out.println("Connection database fail");
    }
}
 

public static void main(String[] args) {
    Blade.of()
            .get("/json", ctx -> ctx.json(new Message()).contentType(JSON_CONTENT_TYPE)
                    .header(SERVER_HEADER, SERVER_VALUE))
            .get("/plaintext", ctx -> ctx.body(PLAINTEXT).contentType("text/plain")
                    .header(SERVER_HEADER, SERVER_VALUE))
            .get("/db", Application::db)
            .get("/queries", Application::queries)
            .get("/updates", Application::updates)
            .get("/fortunes", Application::fortunes)
            .disableSession()
            .start(Application.class, args);
}
 

@Test
public void testAuthSuccess() throws Exception {

    Request mockRequest = mockHttpRequest("GET");

    WebContext.init(Blade.of(), "/");

    Map<String, String> headers = new HashMap<>();
    headers.put("Authorization", "Basic YWRtaW46MTIzNDU2");

    when(mockRequest.parameters()).thenReturn(new HashMap<>());
    when(mockRequest.headers()).thenReturn(headers);

    Request  request  = new HttpRequest(mockRequest);
    Response response = mockHttpResponse(200);

    RouteContext context = new RouteContext(request, response);
    context.initRoute(Route.builder()
            .action(AuthHandler.class.getMethod("handle", RouteContext.class))
            .targetType(AuthHandler.class)
            .target(new AuthHandler()).build());

    WebContext.set(new WebContext(request, response, null));

    AuthOption authOption = AuthOption.builder().build();
    authOption.addUser("admin", "123456");

    BasicAuthMiddleware basicAuthMiddleware = new BasicAuthMiddleware(authOption);
    boolean             flag                = basicAuthMiddleware.before(context);
    assertTrue(flag);
}
 

@Override
public void start(Blade blade) throws Exception {
    this.blade = blade;
    this.environment = blade.environment();
    this.processors = blade.processors();
    this.loaders = blade.loaders();

    long startMs = System.currentTimeMillis();

    int padSize = 16;
    log.info("{} {}{}", StringKit.padRight("app.env", padSize), getPrefixSymbol(), environment.get(ENV_KEY_APP_ENV, "default"));
    log.info("{} {}{}", StringKit.padRight("app.pid", padSize), getPrefixSymbol(), BladeKit.getPID());
    log.info("{} {}{}", StringKit.padRight("app.devMode", padSize), getPrefixSymbol(), blade.devMode());

    log.info("{} {}{}", StringKit.padRight("jdk.version", padSize), getPrefixSymbol(), System.getProperty("java.version"));
    log.info("{} {}{}", StringKit.padRight("user.dir", padSize), getPrefixSymbol(), System.getProperty("user.dir"));
    log.info("{} {}{}", StringKit.padRight("java.io.tmpdir", padSize), getPrefixSymbol(), System.getProperty("java.io.tmpdir"));
    log.info("{} {}{}", StringKit.padRight("user.timezone", padSize), getPrefixSymbol(), System.getProperty("user.timezone"));
    log.info("{} {}{}", StringKit.padRight("file.encoding", padSize), getPrefixSymbol(), System.getProperty("file.encoding"));
    log.info("{} {}{}", StringKit.padRight("app.classpath", padSize), getPrefixSymbol(), CLASSPATH);

    this.initConfig();

    String contextPath = environment.get(ENV_KEY_CONTEXT_PATH, "/");
    WebContext.init(blade, contextPath);

    this.initIoc();
    this.watchEnv();
    this.startServer(startMs);
    this.sessionCleaner();
    this.startTask();
    this.shutdownHook();
}
 

@Test
public void testBeanProcessor(){
    Blade blade = Blade.me();
    BeanProcessor beanProcessor = mock(BeanProcessor.class);
    beanProcessor.processor(blade);
    verify(beanProcessor).processor(blade);
}
 

@Test
public void testAuthFail() throws Exception {
    Request mockRequest = mockHttpRequest("GET");

    WebContext.init(Blade.of(), "/");

    Map<String, String> headers = new HashMap<>();
    headers.put("Authorization", "Basic YmxhZGU6YmxhZGUyMg==");

    when(mockRequest.parameters()).thenReturn(new HashMap<>());
    when(mockRequest.headers()).thenReturn(headers);

    Request  request  = new HttpRequest(mockRequest);
    Response response = mockHttpResponse(200);

    RouteContext context = new RouteContext(request, response);

    context.initRoute(Route.builder()
            .action(AuthHandler.class.getMethod("handle", RouteContext.class))
            .targetType(AuthHandler.class)
            .target(new AuthHandler()).build());

    WebContext.set(new WebContext(request, response, null));

    AuthOption authOption = AuthOption.builder().build();
    authOption.addUser("admin", "123456");

    BasicAuthMiddleware basicAuthMiddleware = new BasicAuthMiddleware(authOption);
    boolean             flag                = basicAuthMiddleware.before(context);
    assertFalse(flag);
}
 

public HttpServerInitializer(SslContext sslCtx, Blade blade, ScheduledExecutorService service) {
    this.sslCtx = sslCtx;
    this.blade = blade;
    this.useGZIP = blade.environment().getBoolean(Const.ENV_KEY_GZIP_ENABLE, false);
    this.isWebSocket = blade.routeMatcher().getWebSockets().size() > 0;
    this.httpServerHandler = new HttpServerHandler();

    service.scheduleWithFixedDelay(() -> date = DateKit.gmtDate(LocalDateTime.now()), 1000, 1000, TimeUnit.MILLISECONDS);
}
 

@Before
public void before() {
    request = mock(Request.class);
    when(request.header("Accept")).thenReturn("text/html");
    response = mock(Response.class);

    WebContext.init(Blade.me(), "/");
    WebContext.set(new WebContext(request, response, null));
}
 

@Test
public void testStart() throws Exception {
    NettyServer nettyServer = new NettyServer();
    nettyServer.start(Blade.of().listen(10087));
    nettyServer.stop();
}
 

@Before
public void before() {
    app = Blade.me();
    app.scanPackages("com.blade.model","com.blade.ioc");
    app.listen(10087).start().await();
}
 

@Test
public void testCreateServer() throws Exception {
    Server server = new NettyServer();
    server.start(Blade.me().listen(10086));
    server.stop();
}
 

@Override
public void processor(Blade blade) {
    JetbrickTemplateEngine templateEngine = new JetbrickTemplateEngine();

    List<String> macros = new ArrayList<>(8);
    macros.add(File.separatorChar + "comm" + File.separatorChar + "macros.html");
    // 扫描主题下面的所有自定义宏
    String themeDir = AttachController.CLASSPATH + "templates" + File.separatorChar + "themes";
    File[] dir      = new File(themeDir).listFiles();
    for (File f : dir) {
        if (f.isDirectory() && Files.exists(Paths.get(f.getPath() + File.separatorChar + "macros.html"))) {
            String macroName = File.separatorChar + "themes" + File.separatorChar + f.getName() + File.separatorChar + "macros.html";
            macros.add(macroName);
        }
    }
    StringBuffer sbuf = new StringBuffer();
    macros.forEach(s -> sbuf.append(',').append(s));
    templateEngine.addConfig("jetx.import.macros", sbuf.substring(1));

    GlobalResolver resolver = templateEngine.getGlobalResolver();
    resolver.registerFunctions(Commons.class);
    resolver.registerFunctions(Theme.class);
    resolver.registerFunctions(AdminCommons.class);
    resolver.registerTags(JetTag.class);

    JetGlobalContext context = templateEngine.getGlobalContext();
    context.set("version", environment.get("app.version", "v1.0"));
    context.set("enableCdn", environment.getBoolean("app.enableCdn", false));

    blade.templateEngine(templateEngine);

    TaleConst.ENABLED_CDN = environment.getBoolean("app.enableCdn", false);
    TaleConst.MAX_FILE_SIZE = environment.getInt("app.max-file-size", 20480);

    TaleConst.AES_SALT = environment.get("app.salt", "012c456789abcdef");
    TaleConst.OPTIONS.addAll(optionsService.getOptions());
    String ips = TaleConst.OPTIONS.get(Types.BLOCK_IPS, "");
    if (StringKit.isNotBlank(ips)) {
        TaleConst.BLOCK_IPS.addAll(Arrays.asList(ips.split(",")));
    }
    if (Files.exists(Paths.get(AttachController.CLASSPATH + "install.lock"))) {
        TaleConst.INSTALLED = Boolean.TRUE;
    }

    BaseController.THEME = "themes/" + Commons.site_option("site_theme");

    TaleConst.BCONF = environment;
}
 

@Test
public void testManager() {
    EventManager eventManager = new EventManager();
    eventManager.addEventListener(EventType.SERVER_STARTED, b -> System.out.println("server started"));
    eventManager.fireEvent(EventType.SERVER_STARTED, new Event().attribute("blade", Blade.of()));
}
 

public static void main(String[] args) {
    Blade.of()
            .start();
}
 

public static void main(String[] args) {
    Blade.me()
            .get("/hello", ((request, response) -> response.text("Hello World.")))
            .start(Hello.class, args);
}
 

public StaticFileHandler(Blade blade) {
    this.showFileList = blade.environment().getBoolean(Const.ENV_KEY_STATIC_LIST, false);
    this.httpCacheSeconds = blade.environment().getLong(Const.ENV_KEY_HTTP_CACHE_TIMEOUT, 86400 * 30);
}
 

public WebSocketHandler(Blade blade) {
    this.blade = blade;
}
 

private WebSocketHandlerWrapper(Blade blade) {
    this.blade = blade;
}
 

public static WebSocketHandlerWrapper init(Blade blade) {
    return new WebSocketHandlerWrapper(blade);
}
 

public SessionHandler(Blade blade) {
    this.blade = blade;
    this.sessionManager = blade.sessionManager();
    this.timeout = blade.environment().getInt(ENV_KEY_SESSION_TIMEOUT, 1800);
}
 

public static void main(String[] args) throws Exception {
    Blade blade = Blade.me();
    TaleLoader.init(blade);
    blade.use(new ValidatorMiddleware(), new CsrfMiddleware()).start(Application.class, args);
}
 

public static void init(Blade blade) {
    TaleLoader.blade = blade;
    loadPlugins();
    loadThemes();
}
 

/**
 * Initialize the ioc container before execution
 *
 * @param blade Blade instance
 */
default void preHandle(Blade blade) {
}
 

/**
 * Initialize the ioc container after execution
 *
 * @param blade Blade instance
 */
void processor(Blade blade);
 

/**
 * Start blade application
 *
 * @param blade blade instance
 * @throws Exception
 */
void start(Blade blade) throws Exception;