开始使用Jboot

Jboot 使用到了如下的技术,了解 Jboot 之前,请先保证您已经了掌握如下技术:

  • 熟悉 Java 编程语言
  • 熟悉 maven 的基本原理
  • 熟悉 IntelliJ IDEA 或者 Eclipse 等编辑器的使用

交流 QQ 群:

  • 群1:601440615 (已满)
  • 群2:719614554 (开放中)

创建项目

通过 IntelliJ IDEA 创建项目

IntelliJ IDEA 下载地址:https://www.jetbrains.com/idea/ ,下载完成后完成后开始安装,安装过程略。

第一步:打开 IntelliJ IDEA 创建 maven 项目,如下图:

第二步:填写 maven 项目的 GroupId、ArtifactId 和 Version

  • GroupId 一般是包名,用来做项目的唯一标识
  • ArtifactId 一般是项目名
  • Version 是项目的版本

第三步:填写 项目存储路径

创建完毕后,我们会看到如下图所示,注意点击 Enable Auto-Import.

通过 Eclipse 创建项目

略,和 通过 IntelliJ IDEA 创建项目 基本相同。

Maven 依赖

通过 以上步骤建立项目后,我们会在项目目录下找到 pom.xml 文件,这个文件是 maven 的核心文件,maven 是通过 pom.xml 对项目进行依赖配置和管理的。

我们需要在 pom.xml 里添加对 Jboot 的依赖配置,如下代码:

<dependency>
    <groupId>io.jboot</groupId>
    <artifactId>jboot</artifactId>
    <version>1.5.2</version>
</dependency>

如下图所示:

Hello World

一般情况下,对一个新项目的了解是从 Hello World 开始的,因此,我们需要通过 Jboot 来写一个 Hello World 程序。

这个 Hello World 的需求是:

通过编写代码,我们在浏览器访问后输出 “Hello World Jboot” 的文字内容。

通过以上步骤,我们创建好了项目、添加好了 jboot 的maven依赖,接下来我们需要来创建一个叫 IndexController 的java文件,

IndexController 的代码如下:

import io.jboot.Jboot;
import io.jboot.web.controller.JbootController;
import io.jboot.web.controller.annotation.RequestMapping;

@RequestMapping("/")
public class IndexController extends JbootController {

    public void index() {
        renderText("Hello World Jboot");
    }


    public static void main(String[] args) {
        Jboot.run(args);
    }
}

以上代码需要注意以下几点:

  1. IndexController 需要继承 JbootController 或者 Controller
  2. 需要添加 @RequestMapping("/") 请求映射配置
  3. 通过编写 index() 方法来接收请求,并向浏览器输出 "Hello World Jboot" , 此处注意:必须叫 index() 不能修改名字,后续会讲到其原理。

通过运行 IndexController 的 main() 方法,我们可以看到如下的日志输出:

May 10, 2018 5:10:42 PM io.jboot.config.JbootConfigManager warn
警告: Could not find jboot.properties in your class path.
  ____  ____    ___    ___   ______ 
 |    ||    \  /   \  /   \ |      |
 |__  ||  o  )|     ||     ||      |
 __|  ||     ||  O  ||  O  ||_|  |_|
/  |  ||  O  ||     ||     |  |  |  
\  `  ||     ||     ||     |  |  |  
 \____||_____| \___/  \___/   |__|  
                                    
JbootConfig {version='1.5.2', mode='dev', bannerEnable=true, bannerFile='banner.txt', jfinalConfig='io.jboot.web.JbootAppConfig'}
JbootServerConfig {type='undertow', host='0.0.0.0', port=8080, contextPath='/'}
JbootWebConfig {actionCacheEnable=true, actionCacheKeyGeneratorType='default', websocketEnable=false, websocketBufferPoolSize=100, cookieEncryptKey='JBOOT_DEFAULT_ENCRYPT_KEY'}
server classPath : /Users/michael/work/git/jbootdemo/target/classes
server webRoot : /Users/michael/work/git/jbootdemo/target/classes
server started success , url : http://127.0.0.1:8080/

我们看到最后一行日志的内容是:

server started success , url : http://127.0.0.1:8080/

此时我们通过浏览器访问:http://127.0.0.1:8080 , 就可以看到如下内容:

链接数据库

在 Java Web 开发中,几乎 99% 以上的项目都需要和数据库打交道,因此,了解 Jboot 如何连接数据成为了必须。

通过 Jboot 连接数据库只需要做两步:

  1. 创建 jboot.properties 配置文件
  2. 在 jboot.properties 添加数据库连接信息

第一步:在项目的resource目录下创建 jboot.properties 文件,此时,项目的目录结构应该如下:

├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── IndexController.java
│   │   └── resources
│   │       └── jboot.properties #注意文件目录不要错了
│   └── test
│       └── java

第二步:在 jboot.properties 文件添加如下数据库信息:

jboot.datasource.type = mysql
jboot.datasource.url = jdbc:mysql://127.0.0.1:3306/jbootdemo
jboot.datasource.user = root 
jboot.datasource.password =
  • jboot.datasource.type:配置的是数据库的类型,目前 Jboot 支持的数据库类型有:Mysql 、Oracle 、SqlServer 、Postgresql 、Sqlite 和 其他标准的数据库。
  • jboot.datasource.url: 配置的是数据库的连接信息
  • jboot.datasource.user: 配置的是数据库的连接账号
  • jboot.datasource.password: 配置的是数据库的连接密码,没有密码可以留空

通过配置完毕后,Jboot就已经有了访问数据库的能力,我们可以在 IndexController 写一个 dbtest() 方法,来测试下 Jboot 的数据库访问能力,代码如下:

@RequestMapping("/")
public class IndexController extends JbootController {

    public void index() {
        renderText("Hello World Jboot");
    }

    public void dbtest(){
        List<Record> records = Db.find("select * from user");
        renderText(Arrays.toString(records.toArray()));
    }


    public static void main(String[] args) {
        Jboot.run(args);
    }
}

注意:以上代码能够正式运行的前提是:

  1. 你本地安装好mysql数据库,并创建好库 jbootdemo ,因为数据库的连接url是:jdbc:mysql://127.0.0.1:3306/jbootdemo
  2. jbootdemo 下要有数据表 user,因为 sql 查询内容是:select * from user

例如:作者本地数据库的内容如下:

运行 IndexController 的 main() 方法,并访问 http://127.0.0.1:8080/dbtest,会看到如下内容所示:

此时,证明 Jboot 已经能够准确访问数据库。

使用代码生成器

Jboot 内置了一个简易的代码生成器,通过代码生成器运行,Jboot帮开发者生成每个数据库表对应 java 的 model 实体类,同时可以生成带有增、删、改、查基本数据库操作能力的 service 层代码。

在使用 Jboot 代码生成器之前,我们需要在 jboot.properties 配置好数据库的连接信息(以上内容已经提到)。并编写任意名字带有main()方法的执行类,例如我们叫 CodeGenerator, 代码如下:

public class CodeGenerator {

    public static void main(String args[]){
        //依赖model的包名
        String modelPackage = "com.xxx.model";
        //生成service 的包名
        String basePackage = "com.xxx.service";

        JbootModelGenerator.run(modelPackage);
        JbootServiceGenerator.run(basePackage, modelPackage);

    }
}

运行 CodeGenerator 的 main() 方法之后,我们能看到 Jboot 已经帮我们创建好对应的包名和类名,此时,项目的目录如下:

├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── CodeGenerator.java
│   │   │   ├── IndexController.java
│   │   │   └── com
│   │   │       └── xxx
│   │   │           ├── model
│   │   │           │   ├── Article.java
│   │   │           │   ├── User.java
│   │   │           │   └── base
│   │   │           │       ├── BaseArticle.java
│   │   │           │       └── BaseUser.java
│   │   │           └── service
│   │   │               ├── ArticleService.java
│   │   │               ├── UserService.java
│   │   │               └── impl
│   │   │                   ├── ArticleServiceImpl.java
│   │   │                   └── UserServiceImpl.java
│   │   └── resources
│   │       └── jboot.properties
│   └── test
│       └── java

通过 Jboot 代码生成器的运行,项目对应的 model 类和 service 会自动生成,同时 Service 层的代码以及带有了对数据库增、删、改、查的基本能力.

需要注意的是: 再次运行该代码生成器的时候,BaseUser、BaseArticle会被重新覆盖,其他代码不会被覆盖。 若需要重新生成 service 层 和 User、Article 等代码,需要手动删除后,再次运行代码生成器 CodeGenerator 。

自动注入

Jboot 通过 Google Guice 提供了强健稳定的代码注入功能,使用注入功能只需要了解一下三个注解:

  1. @Bean : 声明此类可以被自动注入
  2. @Inject : 对属性进行赋值注入
  3. @Singleton : 申明此类为单例模式,通常和@Bean 一起使用。

通过代码生成器生成的Service层代码就已经默认添加上了 @Bean 和 @Singleton 这两个配置,生成的代码如下:

package com.xxx.service.impl;

import io.jboot.aop.annotation.Bean;
import com.xxx.service.UserService;
import com.xxx.model.User;
import io.jboot.service.JbootServiceBase;

import javax.inject.Singleton;

@Bean
@Singleton
public class UserServiceImpl extends JbootServiceBase<User> implements UserService {

}

我们使用到 UserService 接口的时候,只需要添加 @Inject 注解即可,例如:在 IndexController 需要用到 UserService,代码如下:

@RequestMapping("/")
public class IndexController extends JbootController {

    @Inject
    private UserService userService;

    public void index() {
        renderText("Hello World Jboot");
    }

    public void dbtest() {
        List<Record> records = Db.find("select * from user");
        renderText(Arrays.toString(records.toArray()));
    }


    public void users() {
        // 这里用到了 userService 的查询方法
        List<User> users = userService.findAll();
        renderText(Arrays.toString(users.toArray()));
    }


    public static void main(String[] args) {
        Jboot.run(args);
    }
}

运行 main() 方法后,我们通过浏览访问 http://127.0.0.1:8080/users ,此时,页面显示的内容和 访问 http://127.0.0.1:8080/dbtest 的效果是一样的:

数据库的增删改查

在本章节,我们要完成一个小型的项目,这个项目是一个用户管理系统,他具有以下功能:

  • 显示用户列表,带有分页的功能
  • 可以对单个用户删除
  • 可以对用户进行修改
  • 可以添加新的用户

分页查询

我们可以继续来改造 IndexController,通过修改代码生成器的生成的 UserService,来达到上述要求的功能。

在上述的章节里,我们知道,通过如下的代码可以获得所有的用户信息:

 public void users() {
    List<User> users = userService.findAll();
    renderText(Arrays.toString(users.toArray()));
}

如果要分页,我们需要在UserService添加一个分页的方法,并在 UserServiceImpl 来实现这个分页的方法,代码如下:

UserService.java

public interface UserService {

    // 代码生成器生成的其他方法略
    //...

    public Page<User> paginate(int page, int size);
}

UserServiceImpl.java

@Bean
@Singleton
public class UserServiceImpl extends JbootServiceBase<User> implements UserService {

    public Page<User> paginate(int page, int size) {
        return DAO.paginate(page, size);
    }
}

为了代码更加简洁直观,我们新建一个 UserController 来做用户相关的增删改查功能,代码如下:

@RequestMapping("/user")
public class UserController extends JbootController {

    @Inject
    private UserService userService;

    public void index() {
        int page = getParaToInt("page", 1);
        Page<User> userPage = userService.paginate(page, 10);
        setAttr("pageData", userPage);
        render("/user.html");
    }

}
  • getParaToInt() 可以获得request提交过来的page数据,例如:http://127.0.0.1:8080/user?page=100 ,此时,代码里 page 的值是 100,当不传值得时候,默认值是 1 。
  • 通过 userService.paginate 查询数据库,返回一个 Page 对象,里面包含了 当前页码、总页码 和 数据列表等信息。
  • 通过 setAttr() 把数据结果传递到页面

把数据传递到 user.html 后,需要 user.html 把具体的数据和分页相关在网页上列出来。

第一步:完善数据的显示,user.html内容如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user index</title>
</head>
<body>
<table >
    <tr>
        <th>ID</th>
        <th>登录名</th>
        <th>密码</th>
    </tr>
    #for(user : pageData.list )
    <tr>
        <td>#(user.id)</td>
        <td>#(user.login_name)</td>
        <td>#(user.password)</td>
    </tr>
    #end
</table>
</body>
</html>

此时,运行 main() 方法,访问 http://127.0.0.1:8080/user ,页面显示内容如下:

第二步:完善分页功能。

Jboot应用的分页功能需要自定义一个分页标签,自定义分页标签非常简单,代码内容如下:

@JFinalDirective("myPaginate")
public class MyPaginateDirective extends JbootPaginateDirective {

    protected String getPageAttrName() {
        return "pageData"; //这个值要和Controller里setAttr的第一个参数值相同
    }
}

然后再修改 user.html 内容如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user index</title>
</head>
<body>
<table >
    <tr>
        <th>ID</th>
        <th>登录名</th>
        <th>密码</th>
    </tr>
    #for(user : pageData.list )
    <tr>
        <td>#(user.id)</td>
        <td>#(user.login_name)</td>
        <td>#(user.password)</td>
    </tr>
    #end
</table>
#myPaginate()
    #for(page : pages)
        <a href="#(page.url??)" >#(page.text??)</a>
    #end
#end
</body>
</html>

此时,运行 main() 方法,访问 http://127.0.0.1:8080/user ,页面显示内容如下:

由于数据量太小,同时在我们的代码里,要求每页显示10条数据,所以页面才显示了第一页,当我们在数据库添加数据量超过10条的时候,页面显示内容如下:

同时,上一页、下一页等功能正常使用,如下图:

实际上,#myPaginate() 自定义分页标签还可以做更多的配置,包括功能和样式等,但是这不是本章节要讨论的内容了。

新增功能

为了实现新增功能,我们需要写一个叫 add.html 的页面,并写对应的 Controller,保证可以访问。

add.html 的代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user add</title>
</head>
<body>
<form action="/user/doSave" method="post">
    登录名: <input type="text" name="login_name"> <br/>
    密码: <input type="text" name="password"> <br/>
    <input type="submit" value="提交数据">
</form>
</body>
</html>

通过 add.html 内容我们能看到,当用户点击 提交数据 按钮的时候,页面会把数据提交到 /user/doSave 这个路径上去,所以,需要我们在 UserController 编写一个叫做 doSave() 的方法来接收数据,并保存到数据库。

doSave() 方法内容如下:

public void doSave() {
    String loginName = getPara("login_name");
    String password = getPara("password");

    User user = new User();
    user.setLoginName(loginName);
    user.setPassword(password);

    user.save();

    redirect("/user");
}

doSave() 方法的主要作用是接收数据、把数据保存到数据库、然后跳转到 /user 这个页面去。

修改功能

为了减少代码量,我们直接把 add.html 改造成为可用做新增,也可以用作修改的功能(通常在商业项目中也会这么做),因此,我们需要简单修改下 add.html 代码和 add() 这个方法的代码。

add.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user add</title>
</head>
<body>
<form action="/user/doSave" method="post">
    <input type="hidden" name="id" value="#(id ??)">
    登录名: <input type="text" name="login_name"> <br/>
    密码: <input type="text" name="password"> <br/>
    <input type="submit" value="提交数据">
</form>
</body>
</html>

和新增功能的html对比,增加了 <input type="hidden" name="id" value="#(id ??)"> 这行代码。

add() 方法内容如下:

public void add() {
    int id = getParaToInt("id", 0);
    if (id > 0) { //有id ,说明有数据提交过来,用来做修改的标识。
        setAttr("id", id);
    }
    render("/add.html");
}

同时, doSave()方法也需要修改下,用来区分是新增还是修改,代码如下:

public void doSave() {
    String loginName = getPara("login_name");
    String password = getPara("password");

    long id = getParaToLong("id",0l);


    User user = new User();
    user.setLoginName(loginName);
    user.setPassword(password);
    
    if (id > 0){ //说明是更新
        user.setId(id);
        user.update();
    }else { //说明是新增
        user.save();
    }

    redirect("/user");
}

最后,我们在改造下 user.html ,在表格的后面添加一个 修改 的连接, user.html 代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user index</title>
</head>
<body>
<table >
    <tr>
        <th>ID</th>
        <th>登录名</th>
        <th>密码</th>
        <th>操作</th>
    </tr>
    #for(user : pageData.list )
    <tr>
        <td>#(user.id)</td>
        <td>#(user.login_name)</td>
        <td>#(user.password)</td>
        <td><a href="/user/add?id=#(user.id)">修改</a></td>
    </tr>
    #end
</table>
#myPaginate()
    #for(page : pages)
        <a href="#(page.url??)" >#(page.text??)</a>
    #end
#end
</body>
</html>

此时,页面内容如下,修改功能正常使用。

删除功能

删除功能更加简单,只需要在Controller接收ID,然后调用 userService.delete() 方法就可以了,改造 user.html 代码如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user index</title>
</head>
<body>
<table >
    <tr>
        <th>ID</th>
        <th>登录名</th>
        <th>密码</th>
        <th>操作</th>
    </tr>
    #for(user : pageData.list )
    <tr>
        <td>#(user.id)</td>
        <td>#(user.login_name)</td>
        <td>#(user.password)</td>
        <td>
            <a href="/user/add?id=#(user.id)">修改</a>
            <a href="/user/del?id=#(user.id)">删除</a>
        </td>
    </tr>
    #end
</table>
#myPaginate()
    #for(page : pages)
        <a href="#(page.url??)" >#(page.text??)</a>
    #end
#end
</body>
</html>

页面显示如下:

我们只需要在 UserController 编写一个 del() 方法,接收id、删除数据库数据,并跳转回 /user 即可完成任务,代码如下:

  public void del() {
    long id = getParaToLong("id",0l);
    userService.deleteById(id);
    redirect("/user");
}

到目前为止,增删改查所有功能完成。

使用缓存提高性能

通过以上内容,我们可以使用Jboot开发一个具有增、删、改、查基本功能的Java Web 应用,但是,在互联网的应用里,高并发的要求可以说是必不可少的,缓存在提高应用性能和并发上有绝对的话语权。

在 Jboot 里,我们如何来使用缓存呢?

Jboot 提供了两种方案:

  1. 注解
  2. 手写代码

在注解中,Jboot提供了4个注解,方便的对缓存进行操作,他们分别是:

  • @Cacheable
  • @CachePut
  • @CacheEvict
  • @CachesEvict

如何来使用呢?

在以上的章节里,我们知道,如下的代码是一个分页查询的功能:

public class UserServiceImpl extends JbootServiceBase<User> implements UserService {

    public Page<User> paginate(int page, int size) {
        return DAO.paginate(page, size);
    }
}

如何来让 paginate(int page, int size) 方法具有缓存的功能呢?

非常简单:

public class UserServiceImpl extends JbootServiceBase<User> implements UserService {

    @Cacheable(name = "myCache",key = "page:#(page)-#(size)")
    public Page<User> paginate(int page, int size) {
        return DAO.paginate(page, size);
    }
}

只需要添加 @Cacheable(name = "myCache",key = "page:#(page)-#(size)") 这个注解。

在Jboot中,默认的缓存为 EhCache , 这个注解的含义是:

  • 在EhCache中创建一个缓存为myCache的缓存区
  • 当查询第 1 页的时候,缓存的key为:page:1-10,因为 paginate(int page, int size) 方法在执行的时候,传递过来的值分别是:page=1,size=10
  • 当查询第 2 页的时候,缓存的key为:page:2-10,原因同上。

paginate(int page, int size) 方法使用 @Cacheable 缓存之后,只有第一次访问的时候去查询数据库,之后的访问会直接从缓存中获取数据,大大提高了性能。

但是...

使用缓存也会带来一些问题,因为 paginate(int page, int size) 方法不再访问数据库,从而导致我们在数据库对数据进行增、删、改,这个页面数据都不会再发生变化。

要让 paginate(int page, int size) 方法与数据库同步,怎么办呢?

需要我们在对数据库进行 增、删、改 的时候,清除这个方法里的缓存数据。

代码如下:

public class UserServiceImpl extends JbootServiceBase<User> implements UserService {

    @Cacheable(name = "myCache",key = "page:#(page)-#(size)")
    public Page<User> paginate(int page, int size) {
        return DAO.paginate(page, size);
    }

    @Override
    @CacheEvict(name = "myCache",key = "*")
    public boolean save(User model) {
        return super.save(model);
    }

    @Override
    @CacheEvict(name = "myCache",key = "*")
    public boolean update(User model) {
        return super.update(model);
    }

    @Override
    @CacheEvict(name = "myCache",key = "*")
    public boolean delete(User model) {
        return super.delete(model);
    }
}

重写父类 JbootServiceBase 的增、删、改的方法,在这些方法添加 @CacheEvict(name = "myCache",key = "*") 注解。

被添加@CacheEvict的方法,在执行之后,会清除 name 为 myCache 的所有key。 也就是清除 paginate(int page, int size) 方法所有的 key 。

这样,就做到了 paginate(int page, int size) 方法与数据库同步的功能了。是不是非常简单呢 ?!

不过 ...

以上,只是 Jboot 缓存功能的冰山一角,Jboot 的缓存非常强大,比如:

  • @CachePut 和 @CachesEvict 又如何使用?什么场景下使用?
  • 如何使用 Redis 或者其他的缓存方案代替默认的 EhCache ,甚至是公司自己内部的缓存方案 ?
  • 分布式缓存如何做 ?
  • 如何设置缓存的失效时间 ?
  • 如何做到整个网页缓存,类似页面静态化?
  • 等等等等

Jboot 都给与类非常完美的支持。

探索Jboot的更多功能...

恭喜你,到目前为止,你已经掌握了使用 Jboot 来开发一个 java web 的基本技能,包含了

  • MVC
  • ORM
  • AOP
  • 代码生成器
  • 使用缓存提高性能
  • 等等

这是非常重要的一步。

但是,Jboot 的功能远远不止这些,以上只是 Jboot 的冰山一角。

Jboot 真正的核心是做微服务的开发,微服务的底层代码是分布式调用RPC,RPC 的框架和实现的方案非常繁杂,不过 Jboot 已经支持了主流 RPC 的实现,其中包含了 Dubbo 、motan、Zbus等, 未来还会添加 gRPC 等更多的支持。

  • 在 RPC 下,Jboot 支持了 RPC 下的 熔断、降级、监控、Opentracing等等功能
  • 在分布式下,Jboot 支持了分布式缓存、分布式Session、分布式锁、分布式任务、统一配置中心
  • 在数据库下,Jboot 支持分库分表、支持 Reids 等nosql数据库的极简调用
  • 在 MQ 下,Jboot 支持 rabbitmq、redismq、zbus 甚至还支持了 阿里云的商业MQ
  • 另外,Jboot还支持了Swagger、Event事件机制、高并发下的限流方案等等更多的惊喜

希望你用的顺手、开心,如果有什么问题,可以通过 顶部菜单的 提问 链接进行提问,我回在第一时间回复您。