blade

by lets-blade

lets-blade / blade

:rocket: Lightning fast and elegant mvc framework for Java8

5.4K Stars 1.1K Forks Last release: about 1 year ago (2.0.15.BETA) Apache License 2.0 769 Commits 12 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Based on Java8 + Netty4 to create a lightweight, high-performance, simple and elegant Web framework 😋

Spend 1 hour to learn it to do something interesting, a tool in addition to the other available frameworks.

🐾 Quick Start | 🎬 Video Tutorial | 🌚 Documentation | :green_book: Guidebook | 💰 Donate | 🇨🇳 简体中文


What Is Blade?

Blade
is a pursuit of simple, efficient Web framework, so that
JavaWeb
development becomes even more powerful, both in performance and flexibility. If you like to try something interesting, I believe you will love it. If you think it's good, you can support it with a star or by donating :blush:

Features

  • [x] A new generation MVC framework that doesn't depend on other libraries
  • [x] Get rid of SSH's bloated, modular design
  • [x] Source is less than
    500kb
    , learning it is also simple
  • [x] RESTful-style routing design
  • [x] Template engine support, view development more flexible
  • [x] High performance, 100 concurrent qps 20w/s
  • [x] Run the
    JAR
    package to open the web service
  • [x] Streams-style API
  • [x]
    CSRF
    and
    XSS
    defense
  • [x]
    Basic Auth
    and
    Authorization
  • [x] Supports plug-in extensions
  • [x] Support webjars resources
  • [x] Tasks based on
    cron
    expressions
  • [x] Built-in a variety of commonly used middleware
  • [x] Built-in JSON output
  • [x] JDK8 +

Overview

» Simplicity: The design is simple, easy to understand and doesn't introduce many layers between you and the standard library. The goal of this project is that the users should be able to understand the whole framework in a single day.
» Elegance:

blade
supports the RESTful style routing interface, has no invasive interceptors and provides the writing of a DSL grammar.
» Easy deploy: supports
maven
package
jar
file running.

Quick Start

Create a basic

Maven
or
Gradle
project.

Do not create a

webapp
project, Blade does not require much trouble.

Run with

Maven
:
    com.bladejava
    blade-mvc
    2.0.15.RELEASE

or

Gradle
:
compile 'com.bladejava:blade-mvc:2.0.15.RELEASE'

Write the

main
method and the
Hello World
:
public static void main(String[] args) {
    Blade.of().get("/", ctx -> ctx.text("Hello Blade")).start();
}

Open http://localhost:9000 in your browser to see your first

Blade
application!

Contents

Register Route

HardCode

public static void main(String[] args) {
    // Create Blade,using GET、POST、PUT、DELETE
    Blade.of()
        .get("/user/21", getting)
        .post("/save", posting)
        .delete("/remove", deleting)
        .put("/putValue", putting)
        .start();
}

Controller

@Path
public class IndexController {

@GetRoute("signin")
public String signin(){
    return "signin.html";
}

@PostRoute("signin")
@JSON
public RestResponse doSignin(RouteContext ctx){
    // do something
    return RestResponse.ok();
}

}

Get Request Parameters

Form Parameters

Here is an example:

By Context

public static void main(String[] args) {
    Blade.of().get("/user", ctx -> {
        Integer age = ctx.fromInt("age");
        System.out.println("age is:" + age);
    }).start();
}

By Annotation

@PostRoute("/save")
public void savePerson(@Param String username, @Param Integer age){
    System.out.println("username is:" + username + ", age is:" + age)
}

Test it with sample data from the terminal

curl -X GET http://127.0.0.1:9000/user?age=25
curl -X POST http://127.0.0.1:9000/save -F username=jack -F age=16

Path Parameters

By RouteContext

public static void main(String[] args) {
    Blade blade = Blade.of();
    // Create a route: /user/:uid
    blade.get("/user/:uid", ctx -> {
        Integer uid = ctx.pathInt("uid");
        ctx.text("uid : " + uid);
    });

// Create two parameters route
blade.get("/users/:uid/post/:pid", ctx -> {
    Integer uid = ctx.pathInt("uid");
    Integer pid = ctx.pathInt("pid");
    String msg = "uid = " + uid + ", pid = " + pid;
    ctx.text(msg);
});

// Start blade
blade.start();

}

By Annotation

@GetRoute("/users/:username/:page")
public void userTopics(@PathParam String username, @PathParam Integer page){
    System.out.println("username is:" + usernam + ", page is:" + page)
}

Test it with sample data from the terminal

curl -X GET http://127.0.0.1:9000/users/biezhi/2

Body Parameters

public static void main(String[] args) {
    Blade.of().post("/body", ctx -> {
        System.out.println("body string is:" + ctx.bodyToString())
    }).start();
}

Test it with sample data from the terminal

curl -X POST http://127.0.0.1:9000/body -d '{"username":"biezhi","age":22}'

Parse To Model

This is the

User
model.
public class User {
    private String username;
    private Integer age;
    // getter and setter
}

By Annotation

@PostRoute("/users")
public void saveUser(@Param User user){
    System.out.println("user => " + user);
}

Test it with sample data from the terminal

curl -X POST http://127.0.0.1:9000/users -F username=jack -F age=16

Custom model identification

@PostRoute("/users")
public void saveUser(@Param(name="u") User user){
    System.out.println("user => " + user);
}

Test it with sample data from the terminal

curl -X POST http://127.0.0.1:9000/users -F u[username]=jack -F u[age]=16

Body Parameter To Model

public void getUser(@BodyParam User user){
    System.out.println("user => " + user);
}

Test it with sample data from the terminal

curl -X POST http://127.0.0.1:9000/body -d '{"username":"biezhi","age":22}'

Get Environment

Environment environment = WebContext.blade().environment();
String version = environment.get("app.version", "0.0.1");

Get Header

By Context

@GetRoute("header")
public void getHeader(RouteContext ctx){
    System.out.println("Host => " + ctx.header("Host"));
    // get useragent
    System.out.println("UserAgent => " + ctx.userAgent());
    // get client ip
    System.out.println("Client Address => " + ctx.address());
}

By Annotation

@GetRoute("header")
public void getHeader(@HeaderParam String Host){
    System.out.println("Host => " + Host);
}

Get Cookie

By Context

@GetRoute("cookie")
public void getCookie(RouteContext ctx){
    System.out.println("UID => " + ctx.cookie("UID"));
}

By Annotation

@GetRoute("cookie")
public void getCookie(@CookieParam String UID){
    System.out.println("Cookie UID => " + UID);
}

Static Resource

Blade builds a few static resource catalog, as long as you will save the resource file in the static directory under the classpath, and then browse http://127.0.0.1:9000/static/style.css

If you want to customize the static resource URL

Blade.of().addStatics("/mydir");

Of course you can also specify it in the configuration file.

application.properties
(location in classpath)
mvc.statics=/mydir

Upload File

By Request

@PostRoute("upload")
public void upload(Request request){
    request.fileItem("img").ifPresent(fileItem -> {
        fileItem.moveTo(new File(fileItem.getFileName()));
    });
}

By Annotation

@PostRoute("upload")
public void upload(@MultipartParam FileItem fileItem){
    // Save to new path
    fileItem.moveTo(new File(fileItem.getFileName()));
}

Set Session

public void login(Session session){
    // if login success
    session.attribute("login_key", SOME_MODEL);
}

Render To Browser

Render JSON

By Context

@GetRoute("users/json")
public void printJSON(RouteContext ctx){
    User user = new User("biezhi", 18);
    ctx.json(user);
}

By Annotation

This form looks more concise 😶

@GetRoute("users/json")
@JSON
public User printJSON(){
    return new User("biezhi", 18);
}

Render Text

@GetRoute("text")
public void printText(RouteContext ctx){
    ctx.text("I Love Blade!");
}

Render Html

@GetRoute("html")
public void printHtml(RouteContext ctx){
    ctx.html("

I Love Blade!

"); }

Render Template

By default all template files are in the templates directory; in most of the cases you do not need to change it.

Default Template

By default, Blade uses the built-in template engine, which is very simple. In a real-world web project, you can try several other extensions.

public static void main(String[] args) {
    Blade.of().get("/hello", ctx -> {
        ctx.attribute("name", "biezhi");
        ctx.render("hello.html");
    }).start(Hello.class, args);
}

The

hello.html
template
<meta charset="UTF-8">
<title>Hello Page</title>



<h1>Hello, ${name}</h1>

Jetbrick Template

Config Jetbrick Template

Create a

BladeLoader
class and load some config
@Bean
public class TemplateConfig implements BladeLoader {

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

}

Write some data for the template engine to render

public static void main(String[] args) {
    Blade.of().get("/hello", ctx -> {
        User user = new User("biezhi", 50);
        ctx.attribute("user", user);
        ctx.render("hello.html");
    }).start(Hello.class, args);
}

The

hello.html
template
<meta charset="UTF-8">
<title>Hello Page</title>



<h1>Hello, ${user.username}</h1>

#if(user.age &gt; 18)
    <p>Good Boy!</p>
#else
    <p>Gooood Baby!</p>
#end

Render API

Redirects

@GetRoute("redirect")
public void redirectToGithub(RouteContext ctx){
    ctx.redirect("https://github.com/biezhi");
}

Redirect API

Write Cookie

@GetRoute("write-cookie")
public void writeCookie(RouteContext ctx){
    ctx.cookie("hello", "world");
    ctx.cookie("UID", "22", 3600);
}

Cookie API

Web Hook

WebHook
is the interface in the Blade framework that can be intercepted before and after the execution of the route.
public static void main(String[] args) {
    // All requests are exported before execution before
    Blade.of().before("/*", ctx -> {
        System.out.println("before...");
    }).start();
}

Logging

Blade uses slf4j-api as logging interface, the default implementation of a simple log package (modified from simple-logger); if you need complex logging you can also use a custom library, you only need to exclude the

blade-log
from the dependencies.
private static final Logger log = LoggerFactory.getLogger(Hello.class);

public static void main(String[] args) { log.info("Hello Info, {}", "2017"); log.warn("Hello Warn"); log.debug("Hello Debug"); log.error("Hello Error"); }

Basic Auth

Blade includes a few middleware, like Basic Authentication; of course, it can also be customized to achieve more complex goals.

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

Specify the user name and password in the

application.properties
configuration file.
http.auth.username=admin
http.auth.password=123456

Change Server Port

There are three ways to modify the port: hard coding it, in a configuration file, and through a command line parameter.

Hard Coding

Blade.of().listen(9001).start();

Configuration For

application.properties

server.port=9001

Command Line

java -jar blade-app.jar --server.port=9001

Configuration SSL

Configuration For

application.properties

server.ssl.enable=true
server.ssl.cert-path=cert.pem
server.ssl.private-key-path=private_key.pem
server.ssl.private-key-pass=123456

Custom Exception Handler

Blade has an exception handler already implemented by default; if you need to deal with custom exceptions, you can do it like follows.

@Bean
public class GlobalExceptionHandler extends DefaultExceptionHandler {

@Override
public void handle(Exception e) {
    if (e instanceof CustomException) {
        CustomException customException = (CustomException) e;
        String code = customException.getCode();
        // do something
    } else {
        super.handle(e);
    }
}

}

Besides looking easy, the features above are only the tip of the iceberg, and there are more surprises to see in the documentation and sample projects:

Change Logs

See Here

Contact

Contributors

Thanks goes to these wonderful people

contributors.svg

Contributions of any kind are welcome!

Licenses

Please see Apache License

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.