Vert.x(vertx) 認證和授權

每個線上系統幾乎都是離不開認證和授權的，Vert.x提供了靈活、簡單、便捷的認證和授權的支持。Vert.x抽象出了兩個核心的認證和授權的接口，一個是 AuthProvider，另一個是User。通過這兩個接口，我們可以非常靈活的實現我們自定義的認證和授權方法。當然，Vert.x也給我們提供了使用 JDBC、Shiro、MongoDB、JWT等授權的實現，我們可以直接使用。

Vert.x提供的認證和授權都非常簡單，多種授權方式都有一定的規律性。一般來講不需要刻意的學習，在使用的過程中，多讀下Vert.x的源碼就能夠非常清楚的了解到Vert.x認證和授權底層的邏輯。但不是每一位開發者都有時間或者心情去讀源碼的，所以，這里我簡單列出關於Vert.x的認證和授權的應用。

使用Vert.x認證和授權，需要經歷三個階段

1. 自己實現AuthProvider和User接口實現一個簡單的認證和授權。

2. 使用Vert.x提供的授權方式，如JDBC

3. 在Web中使用認證和授權來管理訪問權限

1. 自定義授權實現
自定義授權就是自己實現AuthProvider和User這兩個接口，重寫這兩個接口中定義的認證和授權方法，這是Vert.x認證和授權最核心的也是最為底層的，把這兩個接口弄明白了，后面使用JDBC授權，jwt等等都非常簡單。當然了，如果你僅僅是為了使用，那么你可以直接關注第三個階段，認證和授權在Web中的應用。

比如我們要實現一個最簡單的根據用戶名和密碼的認證，只要認證通過了，就可以訪問系統的所有資源這么一個需求，代碼如下：

（0） pom中需要引入依賴

<dependency>
　　<groupId>io.vertx</groupId>
　　<artifactId>vertx-auth-common</artifactId>
　　<version>3.6.2</version>
</dependency>

 

（1）應用代碼

/**
* 認證與授權測試
* 
* @author lenovo
*
*/
public class AuthTest extends AbstractVerticle {

@Override
public void start() throws Exception {

// 創建認證的Provider
AuthProvider provider = new UserNameAndPasswordProvider();
JsonObject authInfo = new JsonObject().put("username", "admin").put("password", "admin");

// 調用認證方法，將認證的數據傳入
provider.authenticate(authInfo, res -> {
if (res.succeeded()) {
// 認證通過，可以獲取到User對象，通過User對象可以進行權限校驗
User user = res.result();

// 授權
user.isAuthorized("save:user", auth -> {
if (auth.succeeded()) {
System.out.println("授權成功");
} else {
System.out.println("授權失敗");
}
});
} else {
System.out.println("認證失敗！");
}
});

}

public static void main(String[] args) {
Vertx.vertx().deployVerticle(new AuthTest());
}

}

 

用法非常簡單，首先創建一個AuthProvider，這里我們使用了

UserNameAndPasswordProvider
這個類是我們自己定義的一個使用用戶名和密碼進行認證的一個Provider，這個類需要username和password，所以我們將這兩個參數放到authInfo中，傳遞給

authenticate
這個方法，這個方法會異步返回認證的結果。如果認證成功，會返回授權的對象User，調用User對象的

isAuthorized
可以進行驗證是否授權。下面是UserNameAndPasswordProvider的一個簡單實現

（2） UserNameAndPasswordProvider 代碼如下

/**
* 自定義認證
*
* @author lenovo
*/
public class UserNameAndPasswordProvider implements AuthProvider {

@Override
public void authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler) {

// authInfo中存儲了認證需要的相關信息，由調用者傳入
String username = authInfo.getString("username");
String password = authInfo.getString("password");

// 判斷用戶名和密碼是否正確
if ("admin".equals(username) && "admin".equals(password)) {
// 密碼驗證通過，需要實例化授權對象，並在Future中響應給調用者

// 實例化授權對象，可以將認證信息傳入
User user = new MyUser(authInfo);
// 所有情況均成功返回，並將授權對象響應回去
resultHandler.handle(Future.succeededFuture(user));
} else {
// 密碼驗證不通過，響應認證失敗
resultHandler.handle(Future.failedFuture("用戶名或者密碼錯誤"));
}

}

}

 

看到上面的代碼，AuthTest中的邏輯就更加清晰了，代碼非常簡單，就不多描述了。

（3）User接口實現

/**
* 授權
* 
* @author lenovo
*
*/
public class MyUser implements User {

private JsonObject authInfo;

public MyUser(JsonObject authInfo) {
this.authInfo = authInfo;
}

/**
* 這里依然是通過resultHandle響應授權信息，返回值為當前對象是為了Fluent調用模式
*/
@Override
public User isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler) {
// 一直返回成功
resultHandler.handle(Future.succeededFuture(true));
return this;
}

@Override
public User clearCache() {
return null;
}

@Override
public JsonObject principal() {
return authInfo;
}

@Override
public void setAuthProvider(AuthProvider authProvider) {

}

}

 

這里只是重寫了

isAuthorized
這個方法，這個方法里，一直異步響應授權成功，並同步返回當前類的實例，是為了級聯調用起來比較方便。這里也非常簡單，不多說。

2. 使用Vert.x提供的授權方式
（1）JDBC授權實現
通過Vert.x提供的接口我們可以自己實現認證和授權，但一般的情況下，我們可能都會選擇使用數據庫來保存認證和授權信息，如果每次我們都要自己實現JDBCAuthProvider會非常麻煩，重復造輪子，因此Vert.x給我們提供了JDBC授權的實現。用法非常簡單。對自定義授權熟悉之后，JDBC授權就非常好理解了。

① 引入pom依賴

<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-auth-jdbc</artifactId>
<version>3.6.2</version>
</dependency>

 

②創建數據表，為了簡單，我們使用5張表

-- 用戶表
create table t_user (
id int primary key auto_increment,
username varchar(40) not null,
password varchar(255) not null
);

-- 角色表
create table t_role(
id int primary key auto_increment,
role_name varchar(40) not null
);

-- 權限表
create table t_permission(
id int primary key auto_increment,
prefix varchar(40) not null
);

-- 用戶角色對應關系表
create table t_user_role (
id int primary key auto_increment,
user_id int not null,
role_id int not null
);

-- 角色權限對應關系表
create table t_role_permission(
id int primary key auto_increment,
role_id int not null,
per_id int not null
);
③編寫測試類


public class JDBCAuthTest extends AbstractVerticle {

private JDBCClient jdbcClient;

@Override
public void start() throws Exception {
// 獲取到數據庫的客戶端
jdbcClient = new JdbcUtils(vertx).getDbClient();

// 這個就是實現了AuthProvider接口的認證的類
JDBCAuth auth = JDBCAuth.create(vertx, jdbcClient);

// 創建用於認證的參數
JsonObject authInfo = new JsonObject();
auth.authenticate(authInfo, res -> {
if (res.succeeded()) {
// 獲取到授權接口
User user = res.result();
System.out.println("認證成功");
} else {
// 認證失敗
System.out.println("認證失敗");
}
});

}

 

public static void main(String[] args) {
Vertx.vertx().deployVerticle(new JDBCAuthTest());
}
}

 

運行之后發現，表也找不到，字段也找不到，為啥呢，因為我們創建的表和Vert.x創建的表的表名和字段名都不一樣。那么如果我們想要使用我們自己的表結構，就要給JDBCAuth設置要執行的SQL有下面的幾個方法

auth.setAuthenticationQuery(""); // 指定認證的SQL
auth.setPermissionsQuery(""); // 指定獲取用戶權限的SQL
auth.setRolesQuery(""); // 指定獲取用戶角色的SQL

好了，到這里，JDBC的認證就完成了，是不是用起來還是比較簡單的。不再需要我們來實現Provider和User接口了。

（2）JWT授權實現
JWT 是 JSON Web Token 的簡稱，通過名字就可以知道，JWT一般是用在web開發中，一種token的認證方式。在開發中用的還是比較多的。Web開發認證的實現主要有兩種方式，第一種是Session的方式，第二種是Token方式，這兩種認證方式的優劣我們這里不進行比較。

JWT認證和上面提到的基於JDBC的認證以及自定義實現的認證不同，JWT認證可以認為是在JDBC認證、手機短信認證或者自定義的認證證實身份之后，給認證者的一個唯一標識，以后認證只需要帶着這個標識就可以了，而不需要再帶着用戶名或者密碼進行認證。以此來保證用戶信息安全。 對於帶着用戶名或者密碼的這種認證方式，在上送用戶名和密碼這些敏感信息的時候，要使用https來保證傳輸信息的安全。

JWT認證核心兩個，一個是生成token，第二個是驗證客戶端上送的token是否正確。下面是具體的開發步驟

①引入pom

<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-auth-jwt</artifactId>
<version>3.6.2</version>
</dependency>

②JDBC認證，並生成token，返回給客戶端

JWTAuthOptions config = new JWTAuthOptions()
.addPubSecKey(new PubSecKeyOptions()
.setAlgorithm("HS256")
.setPublicKey("keyboard cat")
.setSymmetric(true));

JWTAuth provider = JWTAuth.create(vertx, config);

// 模擬認證通過
if("admin".equals("username") ) {
String token = provider.generateToken(new JsonObject(), new JWTOptions());
System.out.println(token);
}
③第二次客戶端帶着token來，服務端進行校驗

JWTAuthOptions config = new JWTAuthOptions()
.addPubSecKey(
new PubSecKeyOptions().setAlgorithm("HS256")
.setPublicKey("keyboard cat")
.setSymmetric(true)
);

JWTAuth provider = JWTAuth.create(vertx, config);

provider.authenticate(new JsonObject().put("jwt", "dfasdfsadfsadfsdfs"), res -> {
System.out.println(res.result());
});

 

在token中帶數據

jwt中可以附帶一些非敏感的數據，比如用戶的ID，再或者時間戳等。那么該怎么帶數據呢，非常簡單。注意上面生成token的代碼中，傳入了兩個參數，一個是JsonObject，另一個是JWTOptions。其中，JsonObject就是在token中附帶的數據。

JsonObject data = new JsonObject()
.put("userId","admin");

String token = provider.generateToken(data, new JWTOptions());

 

如上代碼，就可以在token中帶上userId，那么當我們解析token的時候，就可以取出userId的值了，代碼如下。

// 使用jwt進行認證
provider.authenticate(new JsonObject().put("jwt", jwt), auth -> {
if (auth.succeeded()) {
JWTUser user = (JWTUser) auth.result();
JsonObject authData = user.principal(); // 這里就是token中解析的數據
String userId = authData.getString("userId");
System.out.println(userId);
request.response().end("認證成功！");
} else {
System.out.println("認證失敗");
request.response().end("token無效");
}
});

 

使用jwt的整個認證過程如下：

package stu.vertx.auth.jwt;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpServer;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.auth.PubSecKeyOptions;
import io.vertx.ext.auth.jwt.JWTAuth;
import io.vertx.ext.auth.jwt.JWTAuthOptions;
import io.vertx.ext.auth.jwt.impl.JWTUser;
import io.vertx.ext.jwt.JWTOptions;
import org.apache.commons.lang3.StringUtils;
import stu.vertx.auth.basic.UserNameAndPasswordProvider;

public class JwtAuthVerticle extends AbstractVerticle {

private JWTAuthOptions config = new JWTAuthOptions()
.addPubSecKey(new PubSecKeyOptions()
.setAlgorithm("HS256")
.setPublicKey("keyboard cat")
.setSymmetric(true));

private JWTAuth provider = JWTAuth.create(vertx, config);

@Override
public void start() throws Exception {

HttpServer server = vertx.createHttpServer();

// 處理客戶端請求
server.requestHandler(request -> {
JsonObject req = JwtAuthVerticle.parseQuery(request.query());

// 判斷用戶是否帶token來認證，如果帶token，就直接通過token來認證，否則認為是第一次認證，通過用戶名和密碼的方式進行認證
String jwt = req.getString("jwt");
if (StringUtils.isBlank(jwt)) {

// 先使用默認的用戶名密碼進行認證
UserNameAndPasswordProvider p = new UserNameAndPasswordProvider();
p.authenticate(req, auth -> {
if (auth.succeeded()) {
// 認證通過之后，再生成token，以后就使用token進行認證
JsonObject data = new JsonObject()
.put("userId", "admin");

String token = provider.generateToken(data, new JWTOptions());

request.response().end(token);
} else {
System.out.println("認證失敗");
request.response().end("認證失敗，請輸出正確的用戶名和密碼");
}
});
} else {

// 使用jwt進行認證
provider.authenticate(new JsonObject().put("jwt", jwt), auth -> {
if (auth.succeeded()) {
JWTUser user = (JWTUser) auth.result();
JsonObject authData = user.principal();
String userId = authData.getString("");
System.out.println(userId);
request.response().end("認證成功！");
} else {
System.out.println("認證失敗");
request.response().end("token無效");
}
});
}

});
server.listen(8080);
}


/**
* 把URL后跟的查詢字符串轉成json對象
*
* @param query
* @return
*/
public static JsonObject parseQuery(String query) {
JsonObject data = new JsonObject();
String[] params = query.split("&");
for (String param : params) {
String[] k = param.split("=");
data.put(k[0], k[1]);
}
return data;
}

public static void main(String[] args) {
Vertx.vertx().deployVerticle(new JwtAuthVerticle());
}
}

 

（3）Shiro授權
在應用開發中，很多的應用場景都使用shiro來進行認證和授權。在Vert.x中，也提供了對Shiro的支持。對於shiro的用法這里不再詳細的介紹，大家可以參考網絡上關於shiro的文章，我們這里僅僅介紹shiro在Vert.x中的應用。

在Vert.x中使用shiro，首先要導入shiro的依賴，以及Vert.x-shiro的依賴包，如下

<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-auth-shiro</artifactId>
<version>3.5.6</version>
</dependency>
下面創建shiro的配置文件auth.properties

user.tim=sausages,morris_dancer,developer,vtoons
role.developer=do_actual_work
role.vtoons=place_order
user.admin=admin,manager
在配置文件中，配置了一個admin用戶，他的密碼也是admin，他具有manager角色，下面是認證和授權的案例代碼

/**
* 使用shiro實現認證和授權的演示案例
*
* @author lenovo
*/
public class ShiroAuthVerticle extends AbstractVerticle {

@Override
public void start() throws Exception {
JsonObject config = new JsonObject().put("properties_path", "classpath:auth.properties");
ShiroAuth provider = ShiroAuth.create(vertx, new ShiroAuthOptions().setType(ShiroAuthRealmType.PROPERTIES).setConfig(config));

JsonObject data = new JsonObject()
.put("username", "admin")
.put("password", "admin");
provider.authenticate(data, auth -> {
if (auth.succeeded()) {
System.out.println("認證成功");
User user = auth.result();
user.isAuthorized("role:manager",res->{
if(res.result()) {
System.out.println("授權成功");
} else {
System.out.println("沒有權限");
}
});
} else {
System.out.println("認證失敗");
}
});
}

@Override
public void stop() throws Exception {
super.stop();
}

public static void main(String[] args) {
Vertx.vertx().deployVerticle(new ShiroAuthVerticle());
}
}

 

關於Vert.x提供的認證和授權還有 MongoDB認證，OAuth2認證等等，這里就不再多說了，大家感興趣的話，可以參考https://vertx.io/docs/vertx-auth-oauth2/java/這里有對oauth2的介紹，關於認證和授權，就說到這里了，下面是認證和授權在Web應用中的使用。

3. 認證和授權在Web中的應用
有了AuthProvider和User之后，再來看認證和授權在Web中的應用就非常簡單了。這里我們在Web應用中使用JDBC授權的實現，這也是Web開發中最為常用的。既然使用JDBC授權，那么首先就要創建數據庫，創建表，這里我們就使用Vert.x定義的表，如果你的需求比較復雜，可以定義更復雜的模型，這里為了簡單，就不再擴展了。

① 建表語句如下：

CREATE TABLE `user` (
`username` VARCHAR(255) NOT NULL,
`password` VARCHAR(255) NOT NULL,
`password_salt` VARCHAR(255) NOT NULL
);

CREATE TABLE `user_roles` (
`username` VARCHAR(255) NOT NULL,
`role` VARCHAR(255) NOT NULL
);

CREATE TABLE `roles_perms` (
`role` VARCHAR(255) NOT NULL,
`perm` VARCHAR(255) NOT NULL
);

 

注意：MySQL8 默認對表名區分大小寫，JDBCAuth的實現類中，對表名是大寫的，這就會導致提示找不到表的問題。

② 在路由中使用授權

比如我們想對 /private/* 的請求需要進行認證，其他的請求不需要授權都可以訪問，那么我們就可以只針對/private/*實現攔截，然后進行權限的過濾。

router.route("/private/*").handler(authHandler);
路由后跟一個處理器，也就是攔截到/private/*的請求之后該如何處理，這里不需要再重復造輪子了，可以使用Vert.x提供的處理器RedirectAuthHandler，如下

AuthHandler authHandler = RedirectAuthHandler.create(authProvider,"/login.html");
create方法有兩個參數，第一個就是我們上面花了大量篇幅所描述的authProvider，第二個參數很明顯是一個url，表示如果認證失敗，要跳轉的頁面。當然認證失敗之后要跳轉到登錄頁面，讓用戶進行登錄了。下面是authProvider是如何創建的呢？

AuthProvider authProvider = JDBCAuth.create(vertx, jdbcClient);
到這里，在web應用中使用JDBC認證就完成了，是不是非常簡單。但到這里，我們只是實現了一個認證的處理器，是不是還需要提供一個登錄的處理器呢，不提供登錄的入口，不管如何訪問，都永遠會跳轉到登錄頁。對於登錄的實現也非常簡單，Vert.x也給我們提供了登錄的處理器。

FormLoginHandler formLoginHandler = FormLoginHandler.create(authProvider)
.setDirectLoggedInOKURL("/index.html");

router.route("/login").handler(formLoginHandler);

 

當用戶訪問/login時，會使用FormLoginHandler，這個handle會讀取到表單提交上來的用戶名和密碼，然后傳遞給authProvider進行認證，如果認證通過，則會跳轉到setDirectLoggedInOKURL所指定的地址。當認證通過之后，再訪問/private下的資源就可以了。

router.route("/private/hello").handler(re -> {
re.user().isAuthorized("role:manager", a -> {
System.out.println(a.succeeded());
re.response().end("Over");
});
});

 

比如有上面的私有路徑，在登錄之前，訪問會跳轉到登錄頁面，當登錄成功之后，就可以進入到handle中。通過routeContext對象可以獲取到user對象，通過user對象的isAuthorized方法可以判斷是否有權限。這就完成了認證和授權的整個過程。