MVC

MVC的概念

略

Controller

Controller是JFinal核心类之一，该类作为MVC模式中的控制器。基于JFinal的Web应用的控制器需要继承该类。Controller是定义Action方法的地点，是组织Action的一种方式，一个Controller可以包含多个Action。Controller是线程安全的。

JbootController

JbootController是扩展了JFinal Controller，在Jboot应用中，所有的控制器都应该继承至JbootController。

JbootController新增的普通方法：

新增关于FlashMessage的方法：

FlashMessage 是一种特殊的 attribute，用法和 setAttr 一样，唯一不同的是 setAttr 是用于当前页面渲染，而
setFlashAttr 是用于对 redirect 之后的页面进行渲染。

新增关于JWT的方法：

JWT简介： Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

JWT的相关配置

@RquestMapping

RquestMapping是请求映射，也就是通过@RquestMapping注解，可以让某个请求映射到指定的控制器Controller里去。

使用@RquestMapping

使用@RquestMapping非常简单。只需要在Controller类添加上@RquestMapping注解即可。

例如：

@RequestMapping("/")
public class HelloController extends JbootController{
   public void index(){
        renderText("hello jboot");
   }
}

我们在HelloController控制器上，添加了@RequestMapping(“/“)配置，也就是让当访问 http://127.0.0.1/的时候让HelloController控制的index()这个方法（action）来处理。

[注意]：

• 访问http://127.0.0.1等同于http://127.0.0.1/。
• @RquestMapping 可以使用在任何的 Controller，并 不需要 这个Controller继承至JbootController。

Action

在 Controller 之中定义的 public 方法称为 Action。Action 是请求的最小单位。Action 方法 必须在 Controller 中定义，且必须是 public 可见性。

每个Action对应一个URL地址的映射：

public class HelloController extends Controller { 
    public void index() {
        renderText("此方法是一个action"); 
    }
    public String test() { 
        return "index.html";
    } 
    public String save(User user) { 
        user.save();
        render("index.html");
    } 
}

以上代码中定义了三个 Action，分别是 HelloController.index()、 HelloController.test() 和 HelloController.save(User user)。

Action 可以有返回值，返回值可在拦截器中通过 invocation.getReturnValue() 获取到，以便进行 render 控制。

Action 可以带参数，可以代替 getPara、getBean、getModel 系列方法获取参数，使用 UploadFile 参数时可以代替 getFile 方法实现文件上传。这种传参方式还有一个好处是便于与 swagger 这类 第三方无缝集成，生成 API 文档。

注意： 带参数的Action必须在pom.xml文件里添加如下配置：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <encoding>UTF-8</encoding>
        <!--必须添加compilerArgument配置，才能使用JController方法带参数的功能-->
        <compilerArgument>-parameters</compilerArgument>
    </configuration>
</plugin>

如果 action 形参是一个 model 或者 bean，原先通过 getBean(User.class, “”) 获取 时第二个参数为空字符串或 null，那么与之等价的形参注入只需要用一下@Para(“”)注解即可:

public void save(@Para(“”)User user) { 
    user.save();
    render("index.html");
}

getPara 系列方法

Controller 供了 getPara 系列方法用来从请求中获取参数。getPara 系列方法分为两种类型。 第一种类型为第一个形参为 String 的 getPara 系列方法。该系列方法是对 HttpServletRequest.getParameter(String name) 的 封 装 ， 这 类 方 法 都 是 转 调 了 HttpServletRequest.getParameter(String name)。第二种类型为第一个形参为 int 或无形参的 getPara 系列方法。该系列方法是去获取 urlPara 中所带的参数值。getParaMap 与 getParaNames 分别对应 HttpServletRequest 的 getParameterMap 与 getParameterNames。

getBean 与 getModel 方法

getModel 用来接收页面表单域传递过来的 model 对象，表单域名称以”modelName.attrName”方式命名，getModel 使用的 attrName 必须与数据表字段名完全一样。getBean 方法用于支持传统 Java Bean，包括支持使用 jfnal 生成器生成了 getter、setter 方法的 Model，页面表单传参时使用与 setter 方法相一致的 attrName，而非数据表字段名。 getModel 与 getBean 区别在于前者使用数表字段名而后者使用与 setter 方法一致的属性名进行数据注入。建议优先使用 getBean 方法。

以下是一个简单的示例:

// 定义Model，在此为Blog
public class Blog extends JbootModel<Blog> {
}
// 在页面表单中采用modelName.attrName形式为作为表单域的name 
<form action="/blog/save" method="post">
    <input name="blog.title" type="text"> 
    <input name="blog.content" type="text"> 
    <input value=" 交" type="submit">
</form>
@RequestMapping("/blog")
public class BlogController extends JbootController { 
    public void save() {
        // 页面的modelName正好是Blog类名的首字母小写 
        Blog blog = getModel(Blog.class);
        //如果表单域的名称为 "otherName.title"可加上一个参数来获取
        Blog blog = getModel(Blog.class, "otherName");
        //如果表单域的名称为 "title" 和 "content" 
        Blog blog = getModel(Blog.class, "");
    }
    // 或者 也可以写如下代码,但是注意，只能写一个save方法
    public void save(Blog blog) {
        // do your something
    }
}

上面代码中，表单域采用了”blog.title”、”blog.content”作为表单域的 name 属性，”blog”是类 文件名称”Blog”的首字母变小写，”title”是 blog 数据库表的 title 字段，如果希望表单域使用任 意的 modelName ，只需要在 getModel 时多添加一个参数来指定，例如: getModel(Blog.class, ”otherName”)。

render

渲染器，负责把内容输出到浏览器，在Controller中，提供了如下一些列render方法。

session 与 分布式session

使用session非常简单，直接在Controller里调用getSessionAttr(key) 或 setSessionAttr(key,value) 就可以。

分布式session

在Jboot的设计中，分布式的session是依赖分布式缓存的，jboot中，分布式缓存提供了3种方式：

1. ehcache
2. redis
3. ehredis： 基于ehcache和redis实现的二级缓存框架。

所以，在使用jboot的分布式session之前，需要在jboot.properties配置上jboot分布式的缓存。

例如：

jboot.cache.type=redis
jboot.cache.redis.host = 127.0.0.1
jboot.cache.redis.password = 123456
jboot.cache.redis.database = 1

配置好缓存后，直接在Controller里调用getSessionAttr(key) 或 setSessionAttr(key,value) 即可。

注意： session都是走缓存，如果jboot配置的缓存是ehcache（或者 ehredis）,请注意在ehcache.xml上添加名为 SESSION 的缓存节点。

限流和流量控制

在Jboot中，默认提供了4个注解进行流量管控。4个注解代表着四个不同的流量管控方案，他们分别是：

例如：

@RequestMapping("/limitation")
public class LimitationDemo extends JbootController {
    public static void main(String[] args) {
        Jboot.setBootArg("jboot.limitation.webPath","/limitation/view");
        Jboot.run(args);
    }
    public void index() {
        renderText("render ok");
    }
    /**
     * 所有的请求，每1秒钟只能访问一次
     */
    @EnableRequestLimit(rate = 1)
    public void request() {
        renderText("request() render ok");
    }
    /**
     * 所有的请求，并发量为1个
     */
    @EnableConcurrencyLimit(rate = 1)
    public void con() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        renderText("con() render ok");
    }
    /**
     * 所有的请求，每1秒钟只能访问一次
     * 被限制的请求，自动跳转到 /limitation/request2
     */
    @EnableRequestLimit(rate = 1, renderType = LimitRenderType.REDIRECT, renderContent = "/limitation/request2")
    public void request1() {
        renderText("request1() render ok");
    }
    public void request2() {
        renderText("request2() render ok");
    }
    /**
     * 每个用户，每5秒钟只能访问一次
     */
    @EnablePerUserLimit(rate = 0.2)
    public void user() {
        renderText("user() render ok");
    }
    /**
     * 每个用户，每5秒钟只能访问一次
     * 被限制的请求，渲染文本内容 "被限制啦"
     */
    @EnablePerUserLimit(rate = 0.2, renderType = LimitRenderType.TEXT, renderContent = "被限制啦")
    public void user1() {
        renderText("user1() render ok");
    }
    /**
     * 每个IP地址，每5秒钟只能访问一次
     */
    @EnablePerIpLimit(rate = 0.2)
    public void ip() {
        renderText("ip() render ok");
    }
}

以上代码和注释已经很清楚的描述了每个注解的意义，但是，针对已经上线的项目，使用@EnableXXXLimit进行流量控制并一定是有效的，很多时候我们需要针对突发流量进行限制和管控，因此，除了以上注解意外，Jboot提供了在线流量管理功能。

使用Jboot在线流量管理，首先配置上流量管理的URL地址，例如：

jboot.limitation.webPath = /jboot/limitation

配置好，启动项目，访问 http://127.0.0.1:8080/jboot/limitation 我们可以看到如下内容：

{
"ipRates": {
    "/limitation/ip": {
        "enable": true,
        "rate": 0.2,
        "renderContent": "",
        "renderType": "",
        "type": "ip"
    }
},
"userRates": {
    "/limitation/user": {
        "enable": true,
        "rate": 0.2,
        "renderContent": "",
        "renderType": "",
        "type": "user"
    },
    "/limitation/user1": {
        "enable": true,
        "rate": 0.2,
        "renderContent": "被限制啦",
        "renderType": "text",
        "type": "user"
    }
},
"concurrencyRates": {
    "/limitation/con": {
        "enable": true,
        "rate": 1,
        "renderContent": "",
        "renderType": "",
        "type": "concurrency"
    }
},
"requestRates": {
    "/limitation/request1": {
        "enable": true,
        "rate": 1,
        "renderContent": "/limitation/request2",
        "renderType": "redirect",
        "type": "request"
    },
    "/limitation/request": {
        "enable": true,
        "rate": 1,
        "renderContent": "",
        "renderType": "",
        "type": "request"
    }
}
}

限流API

1. 限流设置

   • 接口：/jboot/limitation/set

   • 参数：

     | 参数 | 描述 |
     | ——————- | ——-|
     | type | 限流类型：支持有 ip,user,request,concurrency，分别代表：单个IP每秒钟限流、单个用户每秒钟限流、每秒钟允许请求的数量，总体并发量设置 |
     | path |要对那个路径进行设置，例如 /user/aabb|
     | rate |设置的数值是多少|

2. 关闭限流管控

   • 接口：/jboot/limitation/close

   • 参数：

     | 参数 | 描述 |
     | ——————- | ——-|
     | type | 限流类型：支持有 ip,user,request,concurrency，分别代表：单个IP每秒钟限流、单个用户每秒钟限流、每秒钟允许请求的数量，总体并发量设置 |
     | path |要对那个路径进行设置，例如 /user/aabb|

3. 开启限流管控

   • 接口：/jboot/limitation/enable

   • 参数：

     | 参数 | 描述 |
     | ——————- | ——-|
     | type | 限流类型：支持有 ip,user,request,concurrency，分别代表：单个IP每秒钟限流、单个用户每秒钟限流、每秒钟允许请求的数量，总体并发量设置 |
     | path |要对那个路径进行设置，例如 /user/aabb|

注意：

1. 通过限流API进行限流，所有的设置都会保存在内存里，因此如果重启服务器后，通过限流API进行限流的所有设置将会失效。
2. 接口的前缀 /jboot/limitation是通过jboot.properties的jboot.limitation.webPath = /jboot/limitation进行设置的。

限流API安全设置

由于限流功能对系统至关重要，为了防止恶意用户猜出限流API对系统进行恶意操作，因此Jboot提供了限流API的权限设置功能，需要通过 通过jboot.properties的jboot.limitation.webAuthorizer = com.xxx.MyAuthorizer进行设置，其中MyAuthorizer需要实现io.jboot.web.limitation.web.Authorizer接口。

例如：

public class MyAuthorizer implements Authorizer {
    @Override
    public boolean onAuthorize(Controller controller) {
        return true;
    }
}

当限流API被请求的时候，会通过 MyAuthorizer 进行权限认证，只有MyAuthorizer通过(onAuthorize返回true)的时候，请求API才会生效。

websocket

在使用websocket之前，需要在jboot.properties文件上配置启动websocket，例如：

jboot.web.websocketEnable = true
jboot.web.websocketBufferPoolSize = 100

jboot.web.websocketBufferPoolSize 在没有配置的情况下，默认值是100。

当做好以上配置后，就可以开始编写websocket的相关代码了。

html代码：

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
服务器返回的信息：
<input type="text" id="show"/>
浏览器发送的信息：
<input type="text" id="msg"/>
<input type="button" value="send" id="send" onclick="send()"/>
<script>
    var ws = null ;
    var target="ws://localhost:8080/websocket/test";
    if ('WebSocket' in window) {
        ws = new WebSocket(target);
    } else if ('MozWebSocket' in window) {
        ws = new MozWebSocket(target);
    } else {
        alert('WebSocket is not supported by this browser.');
    }
    ws.onopen = function(obj){
        console.info('open') ;
        console.info(obj) ;
    } ;
    ws.onclose = function (obj) {
        console.info('close') ;
        console.info(obj) ;
    } ;
    ws.onmessage = function(obj){
        console.info(obj) ;
        document.getElementById('show').value=obj.data;
    } ;
    function send(){
        ws.send(document.getElementById('msg').value);
    }
</script>
</body>
</html>

java代码：

@ServerEndpoint("/websocket/test")
public class Test {
    @OnOpen
    public void onOpen(){
        System.out.println("onOpen");
    }
    @OnClose
    public void onClose(){
        System.out.println("onClose");
    }
    @OnMessage
    public void onMessage(Session session,String msg){
        System.out.println("receive message : "+msg);
        if(session.isOpen()){
            try {
                //发送消息的html页面
                session.getBasicRemote().sendText(msg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}