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

@RequestMapping("/")
public class MyController extends JbootController{
   public void index(){
        renderText("hello jboot");
   }
   
   public static void main(String [] args){
       Jboot.run(args);
   }
}

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

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");
	} 
}

<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>

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

// 定义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
	}
	
}

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

@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");
    }
}

jboot.limitation.webPath = /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"
	}
}
}

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

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

<!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>

@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();
			}
		}
	}
}

#shiroAuthenticated()
  登陆成功：您的用户名是：#(SESSION("username"))
#end

#shiroGuest()
  游客您好
#end

#shiroHasAllPermission(permissionName1,permissionName2)
  您好，您拥有了权限 permissionName1和permissionName2
#end

#shiroHasAllRoles(role1, role2)
  您好，您拥有了角色 role1和role2
#end

#shiroHasAnyPermission(permissionName1,permissionName2)
  您好，您拥有了权限 permissionName1 或 permissionName2 
#end

#shiroHasAllRoles(role1, role2)
  您好，您拥有了角色 role1 或 role2
#end

#shiroHasPermission(permissionName1)
  您好，您拥有了权限 permissionName1 
#end

#shiroHasRole(role1)
  您好，您拥有了角色 role1 
#end

#shiroNoAuthenticated()
  您好，您还没有登陆
#end

#shiroNotHasPermission(permissionName1)
  您好，您没有权限 permissionName1 
#end

#shiroNotHasRole(role1)
  您好，您没有角色role1
#end

#shiroPrincipal()
  您好，您的登陆信息是：#(principal)
#end

public class MyController extends JbootController{

      @RequiresPermissions("permission1")
      public void index(){

	  }
	  
	  @RequiresPermissions(value={"permission1","permission2"},logical=Logincal.AND)
      public void index1(){

	  }
}

public class MyController extends JbootController{

      @RequiresRoles("role1")
      public void index(){

	  }
	  
	  @RequiresRoles(value = {"role1","role2"},logical=Logincal.AND)
      public void userctener(){

	  }
}

public class MyController extends JbootController{

      @RequiresUser
      public void userCenter(){

	  }
	  
	  @RequiresGuest
      public void login(){

	  }
	  
	  @RequiresAuthentication
	  public void my(){
	  
	  }
}

public class JwtController extends JbootController {

    public void index() {
        setJwtAttr("key1", "test1");
        setJwtAttr("key2", "test2");
        
        //do your sth
    }

    public void show() {
        String value = getJwtPara("key1");
        // value : test1
    }
}

jboot.web.jwt.secret = your_secret

  public class MyshiroListener implements  JbootShiroInvokeListener {


        private JbootShiroConfig config = Jboot.config(JbootShiroConfig.class);


        @Override
        public void onInvokeBefore(FixedInvocation inv) {
            //do nothing
        }

        @Override
        public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
            if (result == null || result.isOk()) {
                inv.invoke();
                return;
            }

            int errorCode = result.getErrorCode();
            switch (errorCode) {
                case AuthorizeResult.ERROR_CODE_UNAUTHENTICATED:
                    doProcessUnauthenticated(inv.getController());
                    break;
                case AuthorizeResult.ERROR_CODE_UNAUTHORIZATION:
                    doProcessuUnauthorization(inv.getController());
                    break;
                default:
                    inv.getController().renderError(404);
            }
        }


        public void doProcessUnauthenticated(Controller controller) {
            // 处理认证失败
        }

        public void doProcessuUnauthorization(Controller controller) {
            // 处理授权失败
        }

    };

jboot.shiro.invokeListener=com.xxx.MyshiroListener

  public class MyshiroListener implements  JbootShiroInvokeListener {

        @Override
        public void onInvokeBefore(FixedInvocation inv) {
            String userId = String.valueOf(inv.getController.getJwtPara(USER_ID));

            JwtAuthenticationToken token = new JwtAuthenticationToken();
            token.setUserId(userId);
            token.setToken(userId);
    
            Subject subject = SecurityUtils.getSubject();
            subject.login(token);
    
            return subject;
        }

        @Override
        public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
            // ....
        }

    };

jboot.shiro.invokeListener=com.xxx.MyshiroListener

public class JwtAuthenticationToken implements AuthenticationToken {
    /** 用户id */
    private String userId;
    /** token */
    private String token;
    
    @Override
    public Object getPrincipal() {
        return userId;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
    
    ... getter setter
}

public class JwtAuthorizingRealm extends AuthorizingRealm {

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtAuthenticationToken;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        JwtAuthenticationToken jwtToken = (JwtAuthenticationToken) token;
        String uid = (String) jwtToken.getPrincipal();

        // 此处判断 uid 是否存在，可以访问等操作
       
        return new SimpleAuthenticationInfo(uid, jwtToken.getCredentials(), this.getName());
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 此处获取 uid 角色权限
        return null;
    }
}

public class JwtSubjectFactory extends DefaultWebSubjectFactory {

    @Override
    public Subject createSubject(SubjectContext context) {
        if (context.getAuthenticationToken() instanceof JwtAuthenticationToken) {
            // jwt 不创建 session
            context.setSessionCreationEnabled(false);
        }

        return super.createSubject(context);
    }
}

#---------------------------------------------------------------------------------#
jboot.web.jwt.httpHeaderName=Jwt
jboot.web.jwt.secret=xxxxxxxxx
jboot.web.jwt.validityPeriod=1800000
#---------------------------------------------------------------------------------#```

    [main]
    #cache Manager
    shiroCacheManager = io.jboot.component.shiro.cache.JbootShiroCacheManager
    securityManager.cacheManager = $shiroCacheManager

    #realm
    dbRealm=xxx.JwtAuthorizingRealm
    dbRealm.authorizationCacheName=shiro-authorizationCache
    
    securityManager.realm=$dbRealm

    #session manager
    sessionManager=org.apache.shiro.session.mgt.DefaultSessionManager
    sessionManager.sessionValidationSchedulerEnabled=false

    #use jwt
    subjectFactory=xxx.JwtSubjectFactory
    securityManager.subjectFactory=$subjectFactory
    securityManager.sessionManager=$sessionManager

    #session storage false
    securityManager.subjectDAO.sessionStorageEvaluator.sessionStorageEnabled=false
    

@RequestMapping("/")
public class MainController extends BaseController {

    /**
     * 登录 基于 jwt
     */
    public void postLogin(String loginName, String pwd) {
        // 此处判断用户名密码是否正确
        
        String userId = "userId"; //返回用户ID
        setJwtAttr("userId", userId); //构建jwt
        renderJson(); //返回成功
    }
}

public class SSOAuthenticationToken implements AuthenticationToken {

    /** 用户id */
    private String userId;

    /** 全局会话 code */
    private String ssoCode;

    @Override
    public Object getPrincipal() {
        return userId;
    }

    @Override
    public Object getCredentials() {
        return ssoCode;
    }
    ... getter setter

 public class MyshiroListener implements  JbootShiroInvokeListener {

        @Override
        public void onInvokeBefore(FixedInvocation inv) {
        String ssoCode = inv.getController().getPara("ssoCode");
        String userId = inv.getController().getPara("userId");

        if (StringUtils.isBlank(ssoCode) || StringUtils.isBlank(userId)) {
            return;
        }

        SSOAuthenticationToken token = new SSOAuthenticationToken();
        token.setUserId(userId);
        token.setSsoCode(ssoCode);

        try {
            Subject subject = SecurityUtils.getSubject();
            subject.login(token);
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.getMessage());
        }
    }
}

public class SSOAuthorizingRealm extends AuthorizingRealm {

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof SSOAuthenticationToken;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        SSOAuthenticationToken ssoToken = (SSOAuthenticationToken) token;
        String uid = (String) ssoToken.getPrincipal();
        String ssoCode = token.getCredentials().toString();

        //判断ssoCode是否为 sso 系统颁发

        // 此处判断 uid 是否存在，可以访问等操作
       
        return new SimpleAuthenticationInfo(uid, ssoToken.getCredentials(), this.getName());
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 此处获取 uid 角色权限
        return null;
    }
}

public class MyshiroListener implements  JbootShiroInvokeListener {

        @Override
        public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
        if (result.isOk()) {
                inv.invoke();
                return;
            }
        int errorCode = result.getErrorCode();
            
        switch (errorCode) {
            case AuthorizeResult.ERROR_CODE_UNAUTHENTICATED:
                doProcessUnauthenticated(inv.getController());
                break;
            case AuthorizeResult.ERROR_CODE_UNAUTHORIZATION:
                doProcessuUnauthorization(inv.getController());
                break;
            default:
                inv.getController().renderError(404);
        }
    }


    public void doProcessUnauthenticated(Controller controller) {
        UpmsConfig upmsConfig = Jboot.config(UpmsConfig.class);

        StringBuilder ssoServerUrl = new StringBuilder(upmsConfig.getServerUrl());
        ssoServerUrl.append("/sso/index").append("?").append("appid").append("=").append(upmsConfig.getAppId()).append("sysid").append("=").append(upmsConfig.getSystemId());

        // 回跳地址
        StringBuffer backurl = controller.getRequest().getRequestURL();
        String queryString = controller.getRequest().getQueryString();
        if (StringUtils.isNotBlank(queryString)) {
            backurl.append("?").append(queryString);
        }
        ssoServerUrl.append("&").append("backurl").append("=").append(StringUtils.urlEncode(backurl.toString()));

        controller.redirect(ssoServerUrl.toString());
    }

    public void doProcessuUnauthorization(Controller controller) {
        controller.renderError(403);
    }
}

[main]

#cache Manager
shiroCacheManager = io.jboot.component.shiro.cache.JbootShiroCacheManager
securityManager.cacheManager = $shiroCacheManager

#realm
dbRealm=xxx.SSOAuthorizingRealm
dbRealm.authorizationCacheName=shiro-authorizationCache

securityManager.realm=$dbRealm

#session 基于缓存sessionDao，如果缓存已经实现共享，那么session也同样实现共享
sessionDAO=xxx.SessionDAO
sessionDAO.activeSessionsCacheName=shiro-active-session

#设置sessionCookie
sessionIdCookie=org.apache.shiro.web.servlet.SimpleCookie
sessionIdCookie.name=ssotestaid
#sessionIdCookie.domain=demo.com
#sessionIdCookie.path=
#cookie最大有效期，单位秒，默认30天
sessionIdCookie.maxAge=1800
sessionIdCookie.httpOnly=true

#设置session会话管理
sessionManager=org.apache.shiro.web.session.mgt.DefaultWebSessionManager
sessionManager.sessionDAO=$sessionDAO
sessionManager.sessionIdCookie=$sessionIdCookie
sessionManager.sessionIdCookieEnabled=true
sessionManager.sessionIdUrlRewritingEnabled=false
securityManager.sessionManager=$sessionManager
#session过期时间，单位毫秒，默认两天
securityManager.sessionManager.globalSessionTimeout=1800000

@RequestMapping("/sso")
@EnableCORS
public class SSOController extends BaseController {

    public void index(String appid, String backurl) {
        // 判断 appid 是否正确，backurl 是否正确

        redirect("/sso/login?backurl=" + StringUtils.urlEncode(backurl));
    }

    @Before(GET.class)
    public void login() {
        Subject subject = SecurityUtils.getSubject();
        String backurl = getPara("backurl");

        if (subject.isAuthenticated()) {
            String loginName = (String) subject.getPrincipal();

            // 判断用户id

            String code = (String) subject.getSession(false).getId().toString();

            if (StringUtils.isBlank(backurl)) {
                renderJson(JsonResult.buildSuccess(code));
            } else {
                if (backurl.contains("?")) {
                    backurl += "&ssoCode=" + code + "&userId=" + upmsUser.getId();
                } else {
                    backurl += "?ssoCode=" + code + "&userId=" + upmsUser.getId();
                }
            }

            redirect(backurl);
        } else {
            setAttr("backurl", backurl);
            render("login.html");
        }
    }

    @Before(POST.class)
    @EmptyValidate(value = {
            @Form(name = "loginName", message = "用户名不能为空"),
            @Form(name = "password", message = "密码不能为空"),
    }, renderType = ValidateRenderType.JSON)
    public void postLogin(String loginName, String password) {
        Subject subject = SecurityUtils.getSubject();

        String backUrl = getPara("backUrl", "");
        Ret ret = JsonResult.buildSuccess("登录成功", backUrl);

        if (!subject.isAuthenticated()) {
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginName, password);
            subject.login(usernamePasswordToken);

            // 获取用户 id
            
            Session session = subject.getSession(true);
            String code = session.getId().toString();

            String backurl = getPara("backurl");
            if (StringUtils.isBlank(backurl)) {
                renderJson(JsonResult.buildSuccess(code));
            } else {
                if (backurl.contains("?")) {
                    backurl += "&ssoCode=" + code + "&userId=" + upmsUser.getId();
                } else {
                    backurl += "?ssoCode=" + code + "&userId=" + upmsUser.getId();
                }
            }

            redirect(backurl);
            return;

        }

        renderJson(ret);
    }

    @Before(POST.class)
    @EmptyValidate(value = {
            @Form(name = "code", message = "参数错误"),
    }, renderType = ValidateRenderType.JSON)
    public void code(String code) {
        Object codeCache = null; // 获取缓存全局code

        if (codeCache == null) {
            renderJson(JsonResult.buildError("invalid"));
        } else {
            renderJson(JsonResult.buildSuccess("success"));
        }
    }


    public void logout() {
        // shiro退出登录
        SecurityUtils.getSubject().logout();
        // 跳回原地址
        String redirectUrl = getRequest().getHeader("Referer");
        if (null == redirectUrl) {
            redirectUrl = "/";
        }

        redirect(redirectUrl);
    }
}

jboot.datasource.type=mysql
jboot.datasource.url=jdbc:mysql://127.0.0.1:3306/jbootdemo
jboot.datasource.user=root
jboot.datasource.password=your_password

public class User extends JbootModel<User> {
	public static final User dao = new User().dao();
}

// 创建name属性为James,age属性为25的User对象并添加到数据库
new User().set("name", "James").set("age", 25).save();
// 删除id值为25的User
User.dao.deleteById(25);
// 查询id值为25的User将其name属性改为James并更新到数据库
User.dao.findById(25).set("name", "James").update();
// 查询id值为25的user, 且仅仅取name与age两个字段的值
User user = User.dao.findByIdLoadColumns(25, "name, age");
// 获取user的name属性
String userName = user.getStr("name");
// 获取user的age属性
Integer userAge = user.getInt("age");
// 查询所有年龄大于18岁的user
List<User> users = User.dao.find("select * from user where age>18");
// 分页查询年龄大于18的user,当前页号为1,每页10个user
Page<User> userPage = User.dao.paginate(1, 10, "select *", "from user
where age > ?", 18);

@Table(tableName = "user", primaryKey = "id")
public class User extends JbootModel <Company> {
	
}

// 创建name属性为James,age属性为25的record对象并添加到数据库
Record user = new Record().set("name", "James").set("age", 25);
Db.save("user", user);
// 删除id值为25的user表中的记录
Db.deleteById("user", 25);
// 查询id值为25的Record将其name属性改为James并更新到数据库
user = Db.findById("user", 25).set("name", "James");
Db.update("user", user);
// 获取user的name属性
String userName = user.getStr("name");
// 获取user的age属性
Integer userAge = user.getInt("age");
// 查询所有年龄大于18岁的user
Page<Record> userPage = Db.paginate(1, 10, "select *", "from user where
age > ?", 18);

boolean succeed = Db.tx(new IAtom(){
		public boolean run() throws SQLException {
		int count = Db.update("update account set cash = cash - ? where
		id = ?", 100, 123);
		int count2 = Db.update("update account set cash = cash + ? where
		id = ?", 100, 456);
		return count == 1 && count2 == 1;
	}
});

jboot.datasource.type=mysql
jboot.datasource.url=jdbc:mysql://127.0.0.1:3306/jbootdemo
jboot.datasource.user=root
jboot.datasource.password=your_password

jboot.datasource.a1.type=mysql
jboot.datasource.a1.turl=jdbc:mysql://127.0.0.1:3306/jboot1
jboot.datasource.a1.tuser=root
jboot.datasource.a1.tpassword=your_password

jboot.datasource.a2.type=mysql
jboot.datasource.a2.turl=jdbc:mysql://127.0.0.1:3306/jboot2
jboot.datasource.a2.tuser=root
jboot.datasource.a2.tpassword=your_password

Company company = new Company();
company.setCid("1");
company.setName("name");

company.use("a1").save();

jboot.datasource.a1.type=mysql
jboot.datasource.a1.url=jdbc:mysql://127.0.0.1:3306/jboot1
jboot.datasource.a1.user=root
jboot.datasource.a1.password=your_password
jboot.datasource.a1.table=company

jboot.datasource.a2.type=mysql
jboot.datasource.a2.url=jdbc:mysql://127.0.0.1:3306/jboot2
jboot.datasource.a2.user=root
jboot.datasource.a2.password=your_password
jboot.datasource.a1.table=user,xxx(其他非company表)

Company company = new Company();
company.setCid("1");
company.setName("name");

//company.use("a1").save();
company.save();

jboot.datasource.db1.url = jdbc:mysql://127.0.0.1:3306/db1
jboot.datasource.db1.user = root
jboot.datasource.db1.password = 

jboot.datasource.db2.url = jdbc:mysql://127.0.0.1:3306/db2
jboot.datasource.db2.user = root
jboot.datasource.db2.password = 

jboot.datasource.db3.url = jdbc:mysql://127.0.0.1:3306/db3
jboot.datasource.db3.user = root
jboot.datasource.db3.password = 

public class UserDatabaseShardingStrategyConfig implements ShardingStrategyConfiguration {

    @Override
    public ShardingStrategy build() {
        return shardingStrategy;
    }


    private ShardingStrategy shardingStrategy = new ShardingStrategy() {

        @Override
        public Collection<String> getShardingColumns() {
            //根据id进行分库
            return Sets.newHashSet("id");
        }

        @Override
        public Collection<String> doSharding(Collection<String> availableTargetNames, Collection<ShardingValue> shardingValues) {
            ListShardingValue shardingValue = (ListShardingValue) shardingValues.stream().findFirst().get();

            String dbName = "db" + Math.abs(shardingValue.getValues().iterator().next().toString().hashCode()) % 3;

            System.out.println("插入数据到库：" + dbName);

            //返回通过计算得到的表
            return Sets.newHashSet(dbName);

        }
    };

}

@Table(tableName = "tb_user",
        primaryKey = "id",
         // 具体的表tb_user${0..2} 表示有三张表 tb_user0,tb_user1,tb_user2,
         // main 是默认数据源的名称
        actualDataNodes = "main.tb_user${0..2}",
        //分表策略
        databaseShardingStrategyConfig = UserDatabaseShardingStrategyConfig.class 
)
public class UserModel extends JbootModel<UserModel> {


   //geter setter
}

@Table(tableName = "tb_user",
        primaryKey = "id",
         // 具体的表tb_user${0..2} 表示有三张表 tb_user0,tb_user1,tb_user2,
         // main 是默认数据源的名称
        actualDataNodes = "main.tb_user${0..2}",
        //分表策略
        tableShardingStrategyConfig = UserTableShardingStrategyConfig.class 
)
public class UserModel extends JbootModel<UserModel> {


    //geter setter
}

public class UserTableShardingStrategyConfig implements ShardingStrategyConfiguration {

    @Override
    public ShardingStrategy build() {
        return shardingStrategy;
    }


    private ShardingStrategy shardingStrategy = new ShardingStrategy() {

        @Override
        public Collection<String> getShardingColumns() {
            //根据id进行分表
            return Sets.newHashSet("id");
        }

        @Override
        public Collection<String> doSharding(Collection<String> availableTargetNames, Collection<ShardingValue> shardingValues) {
            ListShardingValue shardingValue = (ListShardingValue) shardingValues.stream().findFirst().get();

            String tableName = "tb_user" + Math.abs(shardingValue.getValues().iterator().next().toString().hashCode()) % 3;

            System.out.println("插入数据到表：" + tableName);

            //返回通过计算得到的表
            return Sets.newHashSet(tableName);

        }
    };

}

jboot.datasource.type=mysql
jboot.datasource.url=jdbc:mysql://127.0.0.1:3306/jbootsharding
jboot.datasource.user=root
jboot.datasource.password=
jboot.datasource.shardingEnable=true

@RequestMapping("/sharding")
public class ShardingController extends JbootController {

    public void index() {
        UserModel user = new UserModel();
        user.setId(StringUtils.uuid());
        user.setName("Michael yang");

        user.save();

        renderText("插入数据成功，请查看数据库...");

    }

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

public class AopDemo extends JbootController {

    @Inject
    CategoryService service;

    public void index() {
        renderHtml("service:" + service.hello(""));
    }
      
    public static void main(String[] args) {
        Jboot.run(args);
    }
}

public interface CategoryService {
    public String hello(String text);
}

@Bean //必须通过 @Bean 进行配置，让CategoryServiceImpl处于自动暴露状态
public class CategoryServiceImpl implements CategoryService {
    @Override
    public String hello(String text) {
        return "CategoryServiceImpl say hello " + text;
    }

}

public class AopDemo extends JbootController {

    @Inject
    MyServiceImpl myService;

    public void index() {
        renderHtml("service:" + myService);
    }
      
    public static void main(String[] args) {
        Jboot.run(args);
    }
}

public class AopDemo extends JbootController {

    @Inject
    CategoryService service;

    @Inject
    @Named("myCategory") //通过@Named指定使用哪个实现类
    CategoryService nameservice;

    public void index() {
        renderHtml("service:" + service.hello("") 
        + "<br /> nameservice:" + nameservice.hello(""));
    }
      
    public static void main(String[] args) {
        Jboot.run(args);
    }
}

@Bean
public class CategoryServiceImpl implements CategoryService {
    @Override
    public String hello(String text) {
        return "CategoryServiceImpl say hello " + text;
    }
}

@Bean(name = "myCategory")
public class NamedCategoryServiceImpl implements CategoryService {
    @Override
    public String hello(String text) {
        return "NamedCategoryServiceImpl say hello " + text;
    }
}

#默认类型为 motan (支持:dubbo,计划支持 grpc 和 thrift)
jboot.rpc.type = motan
#发现服务类型为 consul ，支持zookeeper。
jboot.rpc.registryType = consul
jboot.rpc.registryAddress = 127.0.0.1:8500

public interface HelloService {
    public String hello(String name);
}

@JbootrpcService
public class myHelloServiceImpl  implements HelloService {
    public String hello(String name){
         System.out.println("hello" + name);
         return "hello ok";
    }
}

 HelloService service = Jboot.me().service(HelloService.class);
 service.hello("michael");

public class MyController extends JbootController{
    
    @JbootrpcService
    HelloService service ;
    
    public void index(){
        String text = service.hello();
        renderText(text);
    }
    
}

consul agent -dev

consul agent -dev -client=本机局域网IP

tickTime=2000
dataDir=/var/lib/zookeeper
clientPort=2181

bin/zkServer.sh start

jboot.redis.host=127.0.0.1
jboot.redis.password=xxxx

JbootRedis redis = Jboot.me().getReids();
redis.set("key1","value1");

String value = redis.get("key1");

System.out.println(value); // 输出 value1

JbootRedis redis = Jboot.me().getReids();

//单机模式下
JbootRedisImpl redisImpl = (JbootRedisImpl)redis;
Jedis jedis = redisImpl.getJedis();

//集群模式下
JbootClusterRedisImpl redisImpl = (JbootClusterRedisImpl)redis;
JedisCluster jedis = redisImpl.getJedisCluster();

jboot.redis.host=127.0.0.1
jboot.redis.password=xxxx

## 多个IP用英文逗号隔开
Jboot.redis.host=192.168.1.33,192.168.1.34
jboot.redis.password=xxxx

#默认为redis (支持: redis,activemq,rabbitmq,hornetq,aliyunmq等 )
jboot.mq.type = redis
jboot.mq.redis.host = 127.0.0.1
jboot.mq.redis.password =
jboot.mq.redis.database =

Jboot.me().getMq().addMessageListener(new JbootmqMessageListener(){
        @Override
        public void onMessage(String channel, Object obj) {
           System.out.println(obj);
        }
}, channel);

 Jboot.me().getMq().publish(yourObject, toChannel);

#默认类型为ehcache ehcache (支持:ehcache,redis,ehredis)
jboot.cache.type = redis
jboot.cache.redis.host = 127.0.0.1
jboot.cache.redis.password =
jboot.cache.redis.database =

Jboot.me().getCache().put("cacheName", "key", "value");

@Test
public void testHttpGet(){
    String html = Jboot.httpGet("https://www.baidu.com");
    System.out.println(html);
}

@Test
public void testHttpPost(){
    Map<String, Object> params  = new HashMap<>();
    params.put("key1","value1");
    params.put("key2","value2");


    String html = Jboot.httpGet("http://www.oschina.net/",params);
    System.out.println(html);
}

@Test
public void testHttpPost(){
    String html = Jboot.httpPost("http://www.xxx.com");
    System.out.println(html);
}

@Test
public void testHttpPost(){
    Map<String, Object> params  = new HashMap<>();
    params.put("key1","value1");
    params.put("key2","value2");


    String html = Jboot.httpPost("http://www.oschina.net/",params);
    System.out.println(html);
}

@Test
public void testHttpUploadFile(){
    Map<String, Object> params  = new HashMap<>();
    params.put("file1",file1);
    params.put("file2",file2);


    String html = Jboot.httpPost("http://www.oschina.net/",params);
    System.out.println(html);
}

@Test
public void testHttpDownload() {

    String url = "http://www.xxx.com/abc.zip";
    File downloadToFile = new File("/xxx/abc.zip");

    JbootHttpRequest request = JbootHttpRequest.create(url, null, JbootHttpRequest.METHOD_GET);
    request.setDownloadFile(downloadToFile);

    JbootHttpResponse response = Jboot.me().getHttp().handle(request);

    if (response.isError()){
        downloadToFile.delete();
    }

    System.out.println(downloadToFile.length());
}

jboot.metric.url = /metric.html

public void myaction() {

    Jboot.me().getmetric().counter("myaction").inc();

    renderText("my action");
}

{
	"version": "3.1.3",
	"gauges": {},
	"counters": {
		"myaction": {
				"count": 1
			}
	},
	"histograms": {},
	"meters": {},
	"timers": {}
}

jboot.metric.jmxReporter = true

$ git clone https://github.com/Netflix/Hystrix.git
$ cd Hystrix/hystrix-dashboard
$ ../gradlew appRun
> Building > :hystrix-dashboard:appRun > Running at http://localhost:7979/hystrix-dashboard

docker run --rm -ti -p 7979:7979 kennedyoliveira/hystrix-dashboard

jboot.hystrix.url = /hystrix.stream

jboot.tracing.type=zipkin
jboot.tracing.serviceName=service1
jboot.tracing.url=http://127.0.0.1:9411/api/v2/spans

wget -O zipkin.jar 'https://search.maven.org/remote_content?g=io.zipkin.java&a=zipkin-server&v=LATEST&c=exec'
java -jar zipkin.jar

docker run -d -p 9411:9411 openzipkin/zipkin

# Build the server and also make its dependencies
$ ./mvnw -DskipTests --also-make -pl zipkin-server clean install
# Run the server
$ java -jar ./zipkin-server/target/zipkin-server-*exec.jar

jboot.tracing.url = http://127.0.0.1:9411/api/v2/spans