关于

Jkas介绍

一个开发效率堪比PHP的高效JAVA WEB框架！
Jkas (Java Kit As Server) 是一个为高效Java Web开发而诞生的轻量极框架，是一个基于MVC设计模式的Web应用框架，Jkas作为控制器(Controller)来建立模型与视图的数据交互。这样的设计也使得业务逻辑控制器能够与Servlet API完全脱离开。
框架支持Restful编码规则、URL别名、国际化、模块化、请求过滤、负载均衡（分布式数据库、分布式session）、用户聚合、事件监听、文件监听、定时任务、队列操作、网络通信（socket、udp、websocket、rpc，rmi）、Restful、多种加密体系、多种编码解码及有效性验证等强大功能。轻松实现各种业务需求！
JKAS, It's easy、fast、powerful ！

版本更新日志

version 2.24
更新日期：2022-06-03
增加redis、zookeeper分布式功能
增加mqqt、rocketmq消息队列

version 2.23
更新日期：2022-03-27
增加防XSS攻击内容
String Psafehtml(String p)//去除不安全的html标签
入门

一、环境要求

java jdk 1.8
tomcat 8/resin >4.0
mysql > 5.0

二、Jkas 包结构

内核包名：org.jkas.core
工具包名：org.jkas.utils
插件包名：org.jkas.plugin
视图包名：org.jkas.view;

三、目录结构

data/
     certs/                                           密钥目录
            jkas.license                            框架密钥（开放后已经去除）
     config.ini                                      全局配置文件
     crontab                                        定时任务列表文件
     alias                                             URL别名配置文件

temp/                                                临时目录
       logs/logyyyymm.log                        框架日志文件
          logs/jkas_cron_yyyy-mm.log               框架定时任务日志文件

WEB-INF/
        lib                                               框架库文件目录
        classes/beetl.properties               视图格式化配置
              classes/fastjson.properties          Fastjson配置文件
        classes/redis.properties               Redis参数配置文件
        classes/memcache.properties      Memcache参数配置文件
        web.xml                                      站点配置文件

locale/                                                语言文件目录

static/                                                 CSS/JS资源目录

themes/                                              视图主题目录

四、如何开始

1、导入类库
1.1、方式一：自己手动导入：
自己把Jkas内核及依赖类库下载并复制到WEB-INF目录和你项目的依赖类目录即可（一般为libs目录）
1.2、方式二：开发工具自动导入
Jkas已经提交到Maven Central及阿里云Maven仓库，用不同开发构建工具引用方式如下：
maven:
<dependency>
<groupId>cn.org.jkas</groupId>
<artifactId>jkas</artifactId>
<version>2.33</version>
</dependency>
gradle:
implementation 'cn.org.jkas:jkas:2.33'

Gradle Kotlin DSL:
implementation("cn.org.jkas:jkas:2.33")

2、配置设置
2.1、框架配置文件指定控制器类的入口包：
#控制器映射包路径
app_package=test.z.app
#默认后缀
url_endwith=.do

2.2、容器web.xml配置（一般不用配置，直接复制过去即可）
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>JKAS</display-name>
<description>jkas web kernel</description>
<servlet>
    <servlet-name>routerServlet</servlet-name>
    <servlet-class>org.jkas.Router</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>*.htm</url-pattern>
</servlet-mapping>
    <servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>/jkas.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>*.jl</url-pattern>
</servlet-mapping>
<welcome-file-list>
    <welcome-file>index.htm</welcome-file>
</welcome-file-list>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
<resource-ref>
    <res-ref-name>dbconfig</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>
</web-app>

2.3、数据库链接池配置，分为容器数据库链接池和框架链接池两种方式（用到数据库时才配置）
不管用哪一种方式，记得把框架配置文件里数据库相关配置与容器里的数据源名称要保持一致
2.3.1、框架数据库相关配置：
[DATABASE]
#数据源类型,0为默认容器数据源，1为使用框架配置数据源，框架数据配置文件路径为data/ds/数据源文件名
ds_type=0
#数据库表前缀
table_prefix=jkas_
data_source=dbconfig //必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
#是否开启数据库集群
db_cluster=1
#集群用来写的数据源设置，多个用逗号隔开，必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
data_source_write=dbconfigw
#集群用来读的数据源设置，多个用逗号隔开，必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
data_source_read=dbconfigr1,dbconfigr2
#数据库类型mysql sqlite oracle mssql 暂时只支持mysql和sqlite，非Mysql和sqlite数据库需要自行写完整的sql
db_type=mysql
#开启自定义SQL语句功能
db_custom_sql=1
#配置自定义SQL文件所在目录，SQL自定义文件与模型指定的表名同名，以.m为后缀
db_custom_sql_dir=data/sql

2.3.2、方式一：容器数据库链接池，分resin和tomcat两种，其他容器可自行找教程
resin:
<character-encoding>UTF-8</character-encoding>
    <database>
        <jndi-name>dbconfig</jndi-name>
        <driver type="com.mysql.jdbc.Driver">
        <url>jdbc:mysql://localhost:3306/dbname</url>
        <user>root</user>
        <password>123456</password>
        </driver>
</database>

tomcat：
在context.xml里面配置数据库连接池
<Resource
name="dbconfig" 
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
maxIdle="2"
maxWait="5000"
username="jkasdev_u"
password="123456"
url="jdbc:mysql://localhost:3306/dbname"
maxActive="4"/>
如果用tomcat数据库链接池，记得在项目web.xml里增加相应的引用，数据源名称也要保持一致，如下：
<resource-ref>
    <res-ref-name>dbconfig</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>
2.3.3、方式二：框架数据库链接池
数据源连接文件在系统/data/ds/xxx，xxx为数据源名称，命名要与框架配置文件里数据库设置部分数据源名称保持一致，如：/data/ds/datasource
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/sc_test?characterEncoding=utf8&useSSL=true&useOldAliasMetadataBehavior=true
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 延迟时间
maxWait=3000

3、控制器继承于org.jkas.core.C 类

import org.jkas.core.C;
      public class Index extends C
      {
          public void index()
             {
                echo("Hello Jkas !");
             }
      }

4、模型继承于org.jkas.core.M类,类的命名以M结尾
import org.jkas.core.M;
      public class UserM extends M
      { public UserM()
               { primaryKey("user_id");
               }
        }
5、服务继承于org.jkas.core.S类
import org.jkas.core.S;
      public class UserService extends S
      { public UserService()
               {
               }
        }

6、访问方式
模块名在开启模块功能时有效！
域名[/模块名]/控制器名[/方法名/参数名/参数值/参数名/参数值/.../.../].后缀 //[]方括号里面的内容为可有可无，方法名没有默认为index
如：
http://www.jkas.org/test.do
http://www.jkas.org/test/about.do
http://www.jkas.org/test/about/name/jkas/age/1.do

特殊情况：
方法名为数字开头：方法默认成index,自动把参数名变为id
如：http://www.jkas.org/goods/22.do 则自动访问 http://www.jkas.org/goods/index/id/22.do

参数个数为奇数情况：自动把第一个参数名变为id
如：http://www.jkas.org/goods/detail/22.do 则自动访问 http://www.jkas.org/goods/detail/id/22.do
      http://www.jkas.org/goods/detail/22/k.do 则自动访问 http://www.jkas.org/goods/detail/22/k.do 偶数个数不处理
      http://www.jkas.org/goods/detail/22/k/v.do 则自动访问 http://www.jkas.org/goods/detail/id/22/k/v.do
配置

一、框架配置文件

[SERVER]
#默认语言
locale=zh_CN
#是否禁用语言加载//如果是做api类的，禁语言加载，提升性能
locale_enable=1
#系统名
site_name=JKAS
#默认字符编码
charset=UTF-8
#货币符号
currency_symbol=￥
#控制器映射包路径
app_package=test.z.app
#默认后缀
url_endwith=.do
#url 别名是否开启，开启后需要在/data/alias文件配置好别名设置
url_alias=0
#是否使用https
use_https=0
#最大并发请求设置，0表示不限制
max_requests=0
# 最大用户量设置，0表示不限制
max_sessions=0
#是否开启模块模式，开启后，控制器包名要加上模块名称，同时语言路径也需要加上模块名称，视图模板路径也需要加上模块名称
module_enable=0
#默认模块
module_default=default
#模块列表,该列表指定的模块名，才启用模块功能，全部启用的话，不设置或设置成为*
module_list=test,test2
#样式域名
css_domain=http://css.z.com
#js域名
js_domain=http://js.z.com
#图片域名
img_domain=http://img.z.com
#资源根目录
res_root_path=static
#CSS资源域名
rescss_domain=http://libcss.z.com
#JS资源域名
resjs_domain=http://libjs.z.com
#图片上传保存路径
img_save_path=images

[HTTP]
ignoreVerifySSL=0//1为忽略验证HTTPS证书有效性

#session配置
[SESSION]
#是否开启允许自定义session机制
session_override=1
#自定义session指定类，该自定义类必须继承JkasSession
session_class=test.z.session.MySession
#default|redis|memcache,pass for redis
session_type=memcache
session_host=127.0.0.1:11211
session_pass=123456
session_maxinterval=1

#定时任务
[CRON]
#定时任务的包名
cron_package=test.z.cron
#是否开启定时任务
cron_enable=1
#是否开启定时任务日志输出，定时日志目录为temp/logs/jkas_cron_年-月.log
cron_log_enable=1

[QUEUE]
#是否启用队列
queue_enable=1
#队列执行自定义类
queue_class=test.z.queue.MyQueue
#队列执行间隔时间，单位微秒，1秒=1000微秒
queue_interval=5000

[SOCKET]
#是否开启socket
socket_enable=1
#是否启用自定义socket
socket_override=1
#自定义socket的类，必须继承SocketService
socket_class=test.z.socket.MySocket
#socket端口
socket_port=9999
#socket调用包名设置
socket_package=test.z.socket

[WEBSOCKET]
#是否开启websocket
ws_enable=1
#websocket端口
ws_port=8888
#websocket调用包名设置
ws_package=test.z.websocket

[RPC]
#是否启用RPC
rpc_enable=1
#RPC服务所在包名
rpc_package=test.z.rpc
#RPC端口
rpc_port=9889

[RMI]
#是否启用RMI
rmi_enable=1
#RMI服务所在包名
rmi_package=test.z.rmi
#RMI主机地址
rmi_host=localhost
#RMI端口
rmi_port=9888

[FILTER]
#是否启用过滤器
filter_enabled=1
#过滤字符串，多个用|分开
filter_str=
#过滤指定调用类设置，该类必须继承Filters
filter_class=test.z.filter.Test

[LISTENER]
#是否开启监听器
listener_enable=1
#监听器指定调用类设置，该类必须继承Listener
listener_class=test.z.listener.Test

[MAIL]
#发邮件服务器地址
smtp_host=smtp.qq.com
#邮件端口
smtp_port=465
#邮件认证用户
smtp_user=421361697@qq.com
#邮件认证密码
smtp_pass=************
#邮件是否启用ssl
smtp_ssl=1
#邮件是否开启调试
smtp_debug=0

[UPLOAD]
#默认最大上传文件，单位：k
upload_max_size=1024
#默认上传类型
upload_allow_type=.jpeg,.jpg,.png,.gif
upload_deny_type=.exe,.java

#cache config default|redis|memcache,pass for redis
[CACHE]
#缓存是否启用
cache_enable=1
#缓存类型
cache_type=default
#缓存服务器地址及端口,redis多个集群地址用逗号隔开
cache_host=192.168.54.233:6379
#缓存服务器认证密码
cache_pass=123456
#默认缓存有效时间（分钟)
cache_expired=30

#zookeeper
[ZOOKEEPER]
#是否开启zookeeper，开启服务将在框架启动时自动连接zookeeper节点，并完成默认节点文件加载创建
zk_enable=1
#zookeeper集群地址，多个用逗号隔开
zk_hosts=127.0.0.1:2181
#zookeeper连接超时
zk_timeout=3000

[VIEW]
#是否启用视图，如果做api类应用，禁用视图将提升性能
view_enable=1
#引擎引擎，支持beetl,thymeleaf,freemarker,velocity，默认beetl
view_engine=beetl
#视图模板类型（后缀）
view_tpl=html
#视图模板路径
view_path=themes
#视图模板主题
view_theme=green

[LOG]
#是否开启日志
log_enable=1

[DATABASE]
#数据源类型,0为默认容器数据源，1为使用框架配置数据源，框架数据配置文件路径为data/ds/数据源文件名
ds_type=0
#数据库表前缀
table_prefix=jkas_
#必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
data_source=dbconfig
#是否开启数据库集群
db_cluster=1
#集群用来写的数据源设置，多个用逗号隔开，必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
data_source_write=dbconfigw
#集群用来读的数据源设置，多个用逗号隔开，必须与resin或tomcat配置的数据源保持一致，如果用框架数据源，必须与框架数据源文件名一致
data_source_read=dbconfigr1,dbconfigr2
#数据库类型mysql sqlite oracle mssql 暂时只支持mysql和sqlite，非Mysql和sqlite数据库需要自行写完整的sql
db_type=mysql
#开启自定义SQL语句功能
db_custom_sql=1
#配置自定义SQL文件所在目录，SQL自定义文件与模型指定的表名同名，以.m为后缀
db_custom_sql_dir=data/sql

#用户整合配置
[UCLIENT]
#是否启用，0 不启用，1 启用
uc_enable=0
#接口类型，1为数据库接口，2为网络接口
uc_type=1
#appid，要与用户中心应用id一致
uc_appid=234
#通信密码，要与用户中心应用通信密码保持一致
uc_authkey=sldfdsfsdf
#应用密钥，要与用户中心该应用的应用密钥保持一致，留空将不进行密钥签名
uc_prikey=XXXXXX
#数据库类型，暂时只支持mysql
uc_db_type=mysql
#用户数据源
uc_data_source=dbconfiguc //必须与resin或tomcat配置的数据源保持一致
#是否开启集群模式
uc_db_cluster=1
#写数据源设置，多个用逗号隔开
uc_data_source_write=dbconfigucw1,dbconfigucw2
#读数据源设置，多个用逗号隔开
uc_data_source_read=dbconfigucr1,dbconfigucr2
#用户数据库表前缀
uc_table_prefix=jkas_
#用户中心接口域名
uc_api=http://uc.z.com
#用户中心接口后缀
uc_endwith=.do

二、容器配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>JKAS</display-name>
<description>JKAS WEB SITE</description>
<servlet>
    <servlet-name>routerServlet</servlet-name>
    <servlet-class>org.jkas.Router</servlet-class>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>/jkas.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>routerServlet</servlet-name>
    <url-pattern>*.jl</url-pattern>
</servlet-mapping>

<welcome-file-list>
    <welcome-file>index.do</welcome-file>
</welcome-file-list>

<session-config>
      <session-timeout>30</session-timeout>
</session-config>


<resource-ref>
    <res-ref-name>dbconfig</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>
</web-app>

三、数据库连接池配置

resin或tomcat数据库连接池配置
*(注意把mysql的jdbc驱动复制到相应的web服环境（resin或tomcat) 的lib目录下面)
1、resin数据源:
<character-encoding>UTF-8</character-encoding>
    <database>
        <jndi-name>dbconfig</jndi-name>
        <driver type="com.mysql.jdbc.Driver">
        <url>jdbc:mysql://localhost:3306/dbname</url>
        <user>root</user>
        <password>123456</password>
        </driver>
</database>

2、tomcat数据源
在context.xml里面配置数据库连接池
<Resource
name="dbconfig" 
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
maxIdle="2"
maxWait="5000"
username="jkasdev_u"
password="123456"
url="jdbc:mysql://localhost:3306/dbname"
maxActive="4"/>

3、框架数据源
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/sc_test?characterEncoding=utf8&useSSL=true&useOldAliasMetadataBehavior=true
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 延迟时间
maxWait=3000

4、数据库连接参数解析
<url>jdbc:mysql://192.168.2.181:3306/jkas_master?characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true</url>
用UTF-8编码进行连接；ssl关闭；字段别名可读开启

四、Redis和Memcahce参数配置

1、Redis参数配置，配置文件在位置：WEB-INF/classes/redis.properties
#最大空闲连接数, 默认8个
maxidle=8
#最大连接数, 默认8个
maxconnections=8
#获取连接时的最大等待毫秒数
maxwaitmillis=200
#逐出连接的最小空闲时间默认1800000毫秒(30分钟)
minidlemillis=1800000
#最小空闲连接数, 默认0
minidle=0
#每次逐出检查时逐出的最大数目
maxevictionnum=3
#对象空闲多久后逐出
softminmillis=1800000
#在获取连接的时候检查有效性
onborrow=0
#在空闲时检查有效性
whileidle=0
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
evictionmillis=-1
#连接耗尽时是否阻塞, 0报异常,1阻塞直到超时
block=0
#是否启用pool的jmx管理功能
jmxenabled=1
#是否启用后进先出
lifo=1

2、Memcache参数配置，配置文件位置：WEB-INF/classes/memcache.properties
#设置容错开关
failover=1
#初始链接数
initconn=10#
#最小链接数
minconn=5
#最大链接数
maxconn=250
#每个链接最大空闲时间默认3小时
maxidle=108000000
#设置连接池维护线程的睡眠时间
maintsleep=30
#设置是否使用Nagle算法
nagle=0
#设置socket的读取等待超时值
socketto=3000
#设置连接心跳监测开关
alivecheck=1

基本方法必须继承于org.jkas.core.C或org.jkas.core.M或org.jkas.core.Utils或org.jkas.core.S方能调用

一、系统基本函数

String C(String confkey)//配置读取

int random(int n)//获取随机数0~n

int random(int min,int max)//获取随机数min~max

String randNum()//默认随机6个数字，字符串类型返回

String randNum(int size)//随机size个数字，字符串类型返回

String randStr()//默认随机6个字符0-9 a-z A-Z

String randStr(int size)//随机size个字符0-9 a-z A-Z

String randStr(int size,String sources)//随机从sources里面取size个字符

String randChineseStr()//随机返回1个中文字

String randChineseStr(int size)//随机返回size个中文字

int toInt(String str)//字符串转整数

int toInt(Object str)//对象转换成整数

long toLong(String str)//字符串转长整数

long toLong(Object str)//字符串转长整数

float toFloat(String str)//字符串转浮点数

float toFloat(Object str)//字符串转浮点数

double toDouble(String str)//字符串转双精度

double toDouble(Object str)//字符串转双精度

String str(int num)//整数转字符串

String str(long num)//长整数转字符串

String str(float num)//浮点数转字符串

String str(double num)//双精度数转字符串

String str(Object obj)//对象转字符串

String arr2str(Object[] arr)//把对象数组转成逗号分隔的字符串

String arr2str(Object[] arr,String delimiter)//把对象数组转成指定符号(delimiter)分隔的字符串

String arr2str(Object[] arr,String delimiter,boolean addquotes)//把对象数组转成指定符号(delimiter)分隔的字符串,addquotes为true时为每个元素加上单引号

StringBuilder concat(String str1,String str2,String str3,...,String strn)//字符串连接

String strc(String str1,String str2,String str3,...,String strn)//字符串连接

String strr(String str)//反转字符串

String stra(String str)//升序字符串

String strd(String str)//降序字符串

String strs(String str)//打乱字符串

String stru(String str)//全部转为大写字符

String stru(String str,int pos,int count)//字符串从pos开始count个字符转为大写

String struf(String str)//字符串第一个字符大写

String strul(String str,int count)//字符串从左开始count个字符转为大写

String strur(String str,int count)//字符串从右开始count个字符转为大写

String strl(String str)//全部转为小写字符

String strl(String str,int pos,int count)//字符串从pos开始count个字符转为小写

String strlf(String str)//字符串第一个字符小写

String strll(String str,int count)//字符串从左开始count个字符转为小写

String strlr(String str,int count)//字符串从右开始count个字符转为小写

String strNumberOne(String str)//获取字符串中的第一个数字，含小数

ArrayList<String> strNumbers(String str)//获取字符串中所有数字，含小数

boolean isEmpty(Object obj)//判断对象是否为null或""

boolean isNull(Object obj)//判断对象是否为null

boolean isNumber(String str)//判断字符串是否为数字

String uuid()//获得32位UUID随机码如：1baad974-b648-4066-950d-9f58380dbb14

String sys(String key)//获取系统信息，计算机名，ip、网卡地址等，详情请查看第四条

HashMap<String,String> sys()//以Map格式返回信息所有信息

String sysexec(String cmd);/执行系统命令并返回结果，慎用（高危）

int coreVersion() //框架版本号

String coreVersionName()//框架版本号名称

String name()//框架名称

HashMap<String,Long> jvmmemory()//查看jvm内存情况 total：可使用；used:已使用；free:空闲；max:最大可用

String byteformat(long size）//格化文件大小,自动计算单位

String byteformat(long size,String unit)//格化文件大小,指定单位，单位为K/M/G/T/P之一

float byteformatnum(long size）//格化文件大小,自动计算单位

float byteformatnum(long size,String unit)//格化文件大小,指定单位，单位为K/M/G/T/P之一

float price(float price)//四舍五入，保留2位小数

float price(float price,int scale,int roundingMode) scale 保留小数位数，roundingMode：0:UP，1:DOWN，2:CEILING，3:FLOOR，4:HALF_UP，5:HALF_DOWN，6:HALF_EVEN，7:UNNECESSARY

RoundingMode.CEILING：取右边最近的整数

RoundingMode.DOWN：去掉小数部分取整，也就是正数取左边，负数取右边，相当于向原点靠近的方向取整

RoundingMode.FLOOR：取左边最近的正数

RoundingMode.HALF_DOWN:五舍六入，负数先取绝对值再五舍六入再负数

RoundingMode.HALF_UP:四舍五入，负数原理同上

RoundingMode.HALF_EVEN:这个比较绕，整数位若是奇数则四舍五入，若是偶数则五舍六入

不同舍入模式下的舍入操作汇总
	根据给定的舍入模式将输入数字舍入为一位数的结果
输入数字	UP	DOWN	CEILING	FLOOR	HALF_UP	HALF_DOWN	HALF_EVEN	UNNECESSARY
5.5	6	5	6	5	6	5	6	抛出 ArithmeticException
2.5	3	2	3	2	3	2	2	抛出 ArithmeticException
1.6	2	1	2	1	2	2	2	抛出 ArithmeticException
1.1	2	1	2	1	1	1	1	抛出 ArithmeticException
1.0	1	1	1	1	1	1	1	1
-1.0	-1	-1	-1	-1	-1	-1	-1	-1
-1.1	-2	-1	-1	-2	-1	-1	-1	抛出 ArithmeticException
-1.6	-2	-1	-1	-2	-2	-2	-2	抛出 ArithmeticException
-2.5	-3	-2	-2	-3	-3	-2	-2	抛出 ArithmeticException
-5.5	-6	-5	-5	-6	-6	-5	-6	抛出 ArithmeticException

String priceformat(float price)//默认配置文件中currency_symbol指定的符号+price,如：￥5.00

String priceformat(float price,String symbol)//返回symbol符号+price,如：￥5.00

double calcu(String str);//计算str表达式的值，如：9*(9+9)-6*(8/(4-2))

二、XML操作

1、单一内容读取

HashMap<String,String> xmlparse(String xmlfile,String nodename)

如：

<?xml version="1.0" encoding="UTF-8"?>
<languages>
<l name="welcome_login">Welcome Login！</l>
<l name="user_holder">Enter the username</l>
</languages>

java:

HashMap<String,String> res=xmlparse("login.xml","l");

2、复杂X ML操作

Element xmlfile(String filepath)//解析mxl文件

Element xmlstr(String str)//解析xml字符串

三、ini文件读写

1、导入类：

import org.jkas.utils.iniRW;

2、初始化

IniRW ini=new IniRW(String inipath);//参数为ini路径

3、读取

String get(String key);

4、写入

void set(String key,String value);

5、保存

void save();

四、获取系统信息

HashMap<String,String> sys()//以Map格式返回信息所有信息

String sys(String key)//获取系统信息，计算机名，ip、网卡地址等

key的值为如下参数之一：

computername //计算机名
file.encoding//系统文件编码
file.separator//系统文件路径分隔符
hostname//系统主机名
ip//系统IP
java.class.path//系统java classpath
java.class.version//系统java class版本
java.ext.dirs//系统java 扩展目录
java.home //系统java环境安装目录
java.io.tmpdir//系统临时目录
java.library.path//系统环境变量PATH
java.runtime.name//java运行环境
java.runtime.version//java运行环境版本
java.version//java版本
java.vm.info//java虚拟机信息
java.vm.name//java虚拟机名称
java.vm.version//java虚拟机版本
line.separator//系统换行符
mac//系统网卡地址
os.arch//系统架构
os.name//操作系统名称
os.version//操作系统版本
path.separator//系统路径分隔
user.country//所在国家
user.dir//WEB服务器安装目录
user.language//使用语言环境
user.name//用户名
user.timezone//时区
userdomain//域|工作组
username//系统用户名

文件操作

一、文件读取

String fr(String filepath)
String fr(String filepath ,String charset)//指定编码
String fr(String filepath ,boolean autocode)//自动识别编码，效率偏低
byte[] frb(String filepath)
byte[] frb(File file)
byte[] fb(String filepath)
byte[] fb(File file)
ArrayList<String>frl(String filepath)//按行读到ArrayList，默认UTF-8 可以使用List的forEach方法继续操作，如：frl("f:/k1.txt",true).forEach(line->{echo(line);});
ArrayList<String>frl(String filepath,String charset)//指定编码
ArrayList<String>frl(String filepath,boolean autocode)//自动识别编码，效率偏低
ArrayList<String> flist(String dirpath)//文件夹文件列表，一级
File[] files(String dirpath)//文件夹文件列表，一级

二、文件写入

boolean fw(String filepath,String content)
boolean fw(String filepath,byte[] content)
boolean fw(String filepath,byte[] content,boolean isAppend) //追加方式写入
boolean fwa(String filepath,byte[] content)//追加方式写入
boolean fwa(String filepath,String content)//追加方式写入

三、文件复制移动

1、文件复制
boolean fc(String srcpath,String despath)
boolean fc(File file,String despath)

2、文件移动
boolean fm(String srcpath,String despath)
boolean fm(File file,String despath)

四、文件或目录删除

boolean fd(String filepath)//删除文件或目录，子目及文件将同时删除，慎用！
boolean fd(File file)//删除文件或目录，子目及文件将同时删除，慎用！
boolean df(String filepath)//删除文件
boolean df(File file)//删除文件
long dfrs(String filepath)//删除文件并返回文件大小
long dfrs(File file)//删除文件并返回文件大小
boolean dd(String filepath)//删除目录，子目录及文件将同时删除，慎用！
boolean dd(File file)//删除目录，子目录及文件将同时删除，慎用！

五、其它文件操作

boolean fe(String filepath)//判断文件是否存在
HashMap<String,Object> finfo(String filepath)//返回文件信息 create:创建时间,access:访问时间，modify:修改时间，owner:创建人
long fsize(String filepath)//获取文件大小
long dsize(String path)//获取目录大小
long dsize(File path)//获取目录大小
boolean mkdir(String dir)//创建目录
boolean isdir(String path)//判断是否是目录
boolean isfile(String filepath)//判断是否是文件
String ft(String filepath)//获取文件类型（暂时有问题）
String fs(String filepath)//获取文件后缀名
String fs(File f)//获取文件后缀名
String fn(File f)//获取文件名
String fn(String filepath)
String fns(File f)//获取文件名和后缀
String fns(String filepath)
String fp(File f)//获取文件路径
String fp(String filepath)
String fcode(String filepath)//返回文件编码
图片处理

一、生成缩略图

String thumb(String src,String des,int w,int h,boolean flag)
String thumb(String src,String des,int w,int h,boolean flag,float quality)
flag为是否自动补白，quality生成缩略图质量（0-1）

二、图片加水印

1、文字水印
void watertxt(String picpath,String words,int position,String font,int fontsize,String color,int rotate)
void watertxt(String picpath,String words,int position,String font,int fontsize,String color,int rotate,float opacity)
注：position:1,2,3,4,0分别对应左上，右上，左下，右下，中间，rotate:角度, opacity:水印透明度（0-1)
如：
watertxt("C:/test.jpg","Jkas",0,"微软雅黑",48,"00FF00",45);

2、图片水印
void waterpic(String picpath,String waterpic，int position,int rotate)
void waterpic(String picpath,String waterpic，int position,int rotate,float opacity)
注：position:1,2,3,4,0分别对应左上，右上，左下，右下，中间，rotate:角度, opacity:水印透明度（0-1)
如：
waterpic("C:/test.jpg","C:/water.png",0,0);

三、图片切割

boolean cutimg(String srcpath,int x,int y,int width,int height,String descpath)
/*srcpath:原始图的完整路径 x:切割x坐标起点，y:切割y坐标起点，width:切割宽度，height:切割高度，descpath:切割后保存路径及文件名*/

四、获取图片信息

HashMap<String,Object> imginfo(String imgpath)//返回图片信息，width:图片宽度，height:图片高度，size:图片大小

五、其它图片处理

1、boolean thumbSize(String srcpath,int w,int h,String despath,float quality,boolean keepRatio,int rotate)
/*
srcpath:原图路径 w:缩放宽度，h:缩放高度，despath:缩放后保存路径，quality:图片质量（0-1），keepRotio:是否保持比例，rotate:旋转角度
指定大小进行缩放 * w,h 若图片横比200小，高比300小，不变 * 若图片横比200小，高比300大，高缩小到300，图片比例不变若图片横比200大，高比300小，横缩小到200，图片比例不变 * 若图片横比200大，高比300大，图片按比例缩小，横为200或高为300
*/
2、boolean thumbScale(String srcpath,float scale,String despath,float quality,int rotate)//按照比例进行缩放 scale(0-1)
3、boolean imgRotate(String srcpath,int rotate,String despath)//旋转图片
4、boolean imgWatermark(String srcpath,String waterpath,String despath,int pos,float opacity)//加水印 pos:0-8,分别代表上左，上中，上右，中左，中，中右，下左，下中，下右位置 opacity：透明度（0-1)
5、boolean imgWatermark(String srcpath,String waterpath,String despath,int pos,float opacity,int w,int h)//w,h生成水印后图片的尺寸大小
6、boolean imgCut(String srcpath,String despath,int pos,int cw,int ch,int sw,int sh,boolean keepRatio)//图片切割，pos同上，cw,ch:切割大小，sw,sh：切割后绽放尺寸
7、boolean imgCut(String srcpath,String despath,int x,int y,int cw,int ch,int sw,int sh,boolean keepRatio)//图片切割，x,y切割起始坐标
8、boolean imgFormat(String srcpath,String despath,String format)//转换图片格式，format:png,jpg,gif
9、BufferedImage imgRead(String srcpath)//输入图片数据
10、void imgOut(BufferedImage img,String type)//输出图片数据到客户端,type 图片类型：jpg,png
文件上传

jkas文件上传

上传类型与大小请先在配置文件进行设置
ArrayList<HashMap<String,String>> FILES() //用户上传文件列表
HashMap<String,String> FILE(String name)//通过表单名称获取上传文件信息
结构：
code：状态值 1：成功 -1：类型不允许 -2：文件大小超过上传限制 0：未知错误
error：为空表示成功，不为空表示错误信息
name：文件表单名
size：文件大小
filename：文件真实名
temp_name：文件临时名称
type：文件类型
suffix：文件后缀

进度获取：
content_length 为请求总大小
HashMap<String,Long>upgress=session("jkasupgress");
结构：HashMap<String,Long>
name:receivedsize//name为上传表单名称，receivedsize为已经上传大小，单位为字节（byte)

String imgPath();//返回默认图片保存配置路径
网络操作
HTTP

一、GET请求

String get(String url)//默认30秒超时可以不输入http://
byte[] get(String url,boolean isbinary)//默认30秒超时可以不输入http://

String get(String url,int timeOut)//timeOut：超时限制，单位秒
byte[] get(String url,boolean isbinary,int timeOut)//timeOut：超时限制，单位秒

需要请求头时，按下面方法实现：
导入网络工具包org.jkas.utils.NetUtil，实例化后，调用工具包以下方法实现含有请求头的请求
String get(String url,HashMap<String,String> headers)
byte[] get(String url,HashMap<String,String> headers,boolean isbinary)

二、POST请求

String post(String url)//默认30秒超时
byte[] post(String url,boolean isbinary)//默认30秒超时
String post(String url，int timeOut)//timeOut：超时限制，单位秒
byte[] post(String url,boolean isbinary，int timeOut)//timeOut：超时限制，单位秒
String post(String url,String params)
byte[] post(String url,String params,boolean isbinary)
String post(String url,HashMap<String, Object> params)
byte[] post(String url,HashMap<String, Object> params,boolean isbinary)
String post(String url,HashMap<String, Object> params,int timeOut)
byte[] post(String url,HashMap<String, Object> params,boolean isbinary,int timeOut)
String post(String url,String params,HashMap<String,String>files)//支持上传文件，默认60秒超时,files是键值对，键为上传表单名称，值为文件绝对路径
byte[] post(String url,String params,HashMap<String,String>files,boolean isbinary,int timeOut)//支持上传文件，默认60秒超时,files是键值对，键为上传表单名称，值为文件绝对路径
String post(String url,HashMap<String,Object> params,HashMap<String,String>files)//支持上传文件
byte[] post(String url,HashMap<String,Object> params,HashMap<String,String>files,boolean isbinary)//支持上传文件
String post(String url,HashMap<String,Object> params,HashMap<String,String>files,int timeOut)//支持上传文件
byte[] post(String url,HashMap<String,Object> params,HashMap<String,String>files,boolean isbinary,int timeOut)//支持上传文件
String post(String url,String params,int contentType)//提交无参数据，contentType为提交类型，1：json,2:xml;默认超时请求时间为30秒
byte[] post(String url,String params,int contentType,boolean isbinary)//提交无参数据，contentType为提交类型，1：json,2:xml;默认超时请求时间为30秒
String post(String url,String params,int contentType,int timeOut)//提交无参数据，contentType为提交类型，1：json,2:xml; timeOut:超时限制，单位秒
byte[] post(String url,String params,int contentType,boolean isbinary,int timeOut)//提交无参数据，contentType为提交类型，1：json,2:xml; timeOut:超时限制，单位秒
String post(String url,byte[] params)//提交无参二进制数据，默认超时请求时间为30秒
byte[] post(String url,byte[] params,boolean isbinary)//提交无参二进制数据，默认超时请求时间为30秒
String post(String url,byte[] params,int timeOut)//提交无参二进制数据，timeOut:超时限制，单位秒
byte[] post(String url,byte[] params,boolean isbinary,int timeOut)//提交无参二进制数据，timeOut:超时限制，单位秒

需要请求头时，有下面方法实现：
导入网络工具包org.jkas.utils.NetUtil，实例化后，调用工具包的以下方法实现含有请求头的请求
String postJson(String url,String params,HashMap<String,String> headers)
byte[] postJson(String url,String params,HashMap<String,String> headers,boolean isbinary)
String postXml(String url,String params,HashMap<String,String> headers)
byte[] postXml(String url,String params,HashMap<String,String> headers,boolean isbinary)
String postStr(String url,String params,HashMap<String,String> headers)
byte[] postStr(String url,String params,HashMap<String,String> headers,boolean isbinary)
static String postBytes(String url,byte[] params,HashMap<String,String> headers)
byte[] postBytes(String url,byte[] params,HashMap<String,String> headers,boolean isbinary)
String post(String url, Map<String, Object> params,HashMap<String,String> headers)
byte[] post(String url, Map<String, Object> params,HashMap<String,String> headers,boolean isbinary)
String postFile(String url, Map<String, Object> params,HashMap<String,String> files,HashMap<String,String> headers)
byte[] postFile(String url, Map<String, Object> params,HashMap<String,String> files,HashMap<String,String> headers,boolean isbinary)

需要包含客户端请求证书时，有下面方法实现：
导入网络工具包org.jkas.utils.NetUtil，实例化后，调用以下方法实现含有证书请求
void setNeedCert(boolean needcert)//设置是否启用证书请求
void setCert(String certfile,String certpass)//设置证书文件路径及证书密码，证书格式为PKCS12格式（.p12)
证书举例：
NetUtil net=new NetUtil();
  net.setNeedCert(true);
net.setCert("c:/cert.p12","123456");
  String res=net.get("https://localhost");
net.setNeedCert(false);//下一次请求不用证书
   res=net.get("https://localhost/hello");

需要响应头时，有下面方法实现：
导入网络工具包org.jkas.utils.NetUtil，实例化后，调用以下方法实现含有请求头的请求
void setHeader(boolean needheader)//needheader为true则需要响应头
HashMap<String,String> getHeaders()//获取响应头内容
响应头案例：
NetUtil net=new NetUtil();
  net.setHeader(true);
  String res=net.get("http://localhost");
HashMap<String,String>headers=net.getHeaders();

上传案例：
public void httpup()
{
  HashMap<String,String> files=new HashMap<String,String>();
  files.put("a1","f:/tt.txt");
  files.put("a2","f:/k1.txt");
  echo(post("http://localhost","a=b&c=d",files));
}

三、下载文件

boolean download(String url,String filepath)//下载文件并保存到指定路径
byte[] download(String url)//下载文件，并转为字节流

需要请求头时，按下面方法实现：
导入网络工具包org.jkas.utils.NetUtil，实例化后，调用以下方法实现含有请求头的下载
boolean download(String url,String filepath,HashMap<String,String> headers)//下载文件并保存到指定路径
byte[] download(String url,HashMap<String,String> headers)//下载文件，并转为字节流
SOCKET

一、SOCKET请求

String socket(String ip,int port,String str)
参数：
ip：请求主机地址
port：请求主机商品
str：发送的字符串

返回值：
返回服务器响应一行（目前版本只支持读取一行响应)

二、SOCKET服务端

1、配置
[SOCKET]
#是否开启socket
socket_enable=1
#是否启用自定义socket
socket_override=1
#自定义socket的类，必须继承SocketService
socket_class=test.z.socket.MySocket
#socket端口
socket_port=9999
#socket调用包名设置
socket_package=test.z.socket
#for websocket的验证协议
socket_protocol=jkas

2、信息推送：每次不能大于1024字节
send(String message)
send(byte[] message)
send(String to,String messages)//通过socket推送信息到指定用户 to:用户标识，前端登录时指定，多个用逗号隔开，messages:信息内容,注：仅可在定时任务、过滤器、监听器及控制器中使用
send(String to,byte[] messages)
客户端请求发送数据格式：
{"cmd":"close"}//关闭
{"cmd":"login","uid":"zhou886"}//登录
{"app":"test","data":{"name":"sfsd"}}//其它请求，app指自己写的继承于JkasSocket的类，act:该类的方法，没传act默认为index

socket响应类编写：
socket类必须继承于JkasSocket，方法类型不限定，但最终会以字符串输出到客户端
获取前端参数,即data数据方法：
String D()//获取整个data数据
String D(String key)//获取json结构的data数据指定key的值
案例：
package test.z.socket;
import org.jkas.core.JkasSocket;
public class Test extends JkasSocket
{ public String index()
{return D("name");
}
}

服务端输出：
{"code":200,"msg":"connected"}//连接成功
{"code":200,"msg":"login"}//登录成功
{"code":200,"msg":"closed"}//关闭连接成功
{"code":404,"msg":"Bad Request"}//app或act名称不符要求
{"code":200,"msg":"success"}//收到非Json信息，不做任何处理
{"code":404,"msg":"Please set the package in the configuration file first."}//包名没配置输出
{"code":404,"msg":"notice messages"}//各种提示信息
{"code":500,"msg":"invalid json data"}//请求的JSON数据格式错误
如果是自定义类，字符串原样输出

3、自定义Socket
自定义socket的类，必须继承SocketService
并且要同时开启
socket_enable=1
socket_override=1
开启自定义socket后，socket响应类转发将失效

覆盖如下方法进行自定义类的实现，可以不全部覆盖：
public void OnConnection(Socket socket)//连接成功
public void OnMessage(Socket socket,byte[] message)//收到信息
public void OnError(Socket socket,String error)//出现错误
public void OnClose(Socket socket)//连接断开

案例：
package test.z.socket;
import org.jkas.core.SocketService;
import java.net.Socket;
public class MySocket extends SocketService
{
public MySocket()
{
}
public void onConnection(Socket socket)
{send("custom my socket connected");
}
public void onMessage(Socket socket,byte[] message)
{send("get message:"+new String(message));
}
public void onClose(Socket socket)
{System.out.println("socket close");
}
}
三、SOCKET 客户端
SOCKET 客户端主动请求外部机器
1、配置
[SOCKET CLIENT]
;for client 是否开启服务器主动请求一个外部socket,默认是每分钟检测一次，如果断开，自动重连
socket_client_enable=1
;要请求的外部主机地址
socket_client_host=localhost
;要请求的外部主机端口
socket_client_port=7777
;是否启用类覆盖
socket_client_override=0
;如果启用类覆盖，指定用来覆盖的类名，必须继承SocketClient
socket_client_class=test.z.socket.MySocketClient
;外部主机响应后调用类的包名设置
socket_client_package=test.z.socket

2、信息回应与响应类，每次不能大于1024字节
void sendc(String content)//只能在响应类中调用
void sendc(byte[] content)//只能在响应类中调用
boolean csend(String content)//全局可调用
boolean csend(byte[] content)//全局可调用

外部机器请求发送数据格式：
{"app":"test","data":{"name":"sfsd"}}//其它请求，app指自己写的继承于JkasSocketClient的类，act:该类的方法，没传act默认为index
socket client响应类编写：
socket client类必须继承于JkasSocketClient，方法类型不限定，但最终会以字符串输出到客户端
获取前端参数,即data数据方法：
String D()//获取整个data数据
String D(String key)//获取json结构的data数据指定key的值
案例：
```
package test.z.socket;
import org.jkas.core.JkasSocketClient;
public class TestClient extends 
JkasSocketClient
{ public String index()
 {return D("name");
 }
}
```
响应输出：
{"code":404,"msg":"Bad Request"}//app或act名称不符要求
{"code":200,"msg":"success"}//收到非Json信息，不做任何处理
{"code":404,"msg":"Please set the package in the configuration file first."}//包名没配置输出
{"code":404,"msg":"notice messages"}//各种提示信息
{"code":500,"msg":"invalid json data"}//请求的JSON数据格式错误
如果是自定义类，字符串原样输出

3、自定义Socket Client
自定义socket client的类，必须继承SocketClient
并且要同时开启
socket_client_enable=1
socket_client_override=1
开启自定义socket client后，socket client响应类转发将失效

覆盖如下方法进行自定义类的实现，可以不全部覆盖：
public void OnConnection(SocketChannel channel)//连接成功
public void OnMessage(SocketChannel channel,byte[] message)//收到信息
public void OnError(SocketChannel channel,String error)//出现错误
public void OnClose(SocketChannel channel)//关闭连接
案例：
```
package test.z.socket;import 
java.nio.channels.SocketChannel; import 
org.jkas.core.SocketClient;public class MySocketClient extends 
SocketClient{  
public MySocketClient() { }
 public void OnConnection(SocketChannel sc) { }
public void OnMessage(SocketChannel sc,byte[] message)
{String msg=""; try { msg=new String(message);        
}catch(Exception e) {msg=e.toString();  }
 sendc("goods");
}
 public void OnClose(SocketChannel sc) {System.out.println("socket close"); }
}
```
UDP

一、UDP请求

String udpSocket(String ip,int port,String str)
参数：
ip：请求主机地址
port：请求主机商品
str：发送的字符串

返回值：
返回服务器响应一行（目前版本只支持读取一行响应)

二、UDP服务端

1、配置
[UDP]
；是否开启udp
udp_enable=1
;udp会话过期时间（分钟）
udp_interval=10
;是否启用自定义udp
udp_override=1
;自定义udp的类，必须继承UdpService
udp_class=test.z.udp.MyUdp
;udp端口
udp_port=9998
；udp调用包名设置
udp_package=test.z.udp

2、信息推送：每次不能大于1024字节
usend(String message)
usend(byte[] message)
usend(String to,String messages)//通过udp推送信息到指定用户 to:用户标识，客户端登录时指定，多个用逗号隔开，messages:信息内容,注：仅可在定时任务、过滤器、监听器及控制器中使用
usend(String to,byte[] messages)
客户端请求发送数据格式：
{"cmd":"login","uid":"zhou886"}//登录
{"app":"test","data":{"name":"sfsd"}}//其它请求，app指自己写的继承于JkasUdp的类，act:该类的方法，没传act默认为index

UDP响应类编写：
UDP类必须继承于JkasUdp，方法类型不限定，但最终会以字符串输出到客户端
获取前端参数,即data数据方法：
String D()//获取整个data数据
String D(String key)//获取json结构的data数据指定key的值
案例：
package test.z.udp;
import org.jkas.core.JkasUdp;
public class Test extends JkasUdp
{ public String index()
{ usend("abcdefg");
   return "udp server";
}
}

服务端输出：
{"code":200,"msg":"login"}//登录成功
{"code":404,"msg":"Bad Request"}//app或act名称不符要求
{"code":200,"msg":"success"}//收到非Json信息，不做任何处理
{"code":404,"msg":"Please set the package in the configuration file first."}//包名没配置输出
{"code":404,"msg":"notice messages"}//各种提示信息
如果是自定义类，字符串原样输出

3、自定义Udp
自定义udp的类，必须继承UdpService
并且要同时开启
udp_enable=1
udp_override=1
开启自定义udp后，udp响应类转发将失效

覆盖如下方法进行自定义类的实现，可以不全部覆盖：
public void OnMessage(DatagramPacket packet,byte[] message)//收到信息
public void OnError(DatagramPacket packet,String error)//出现错误

案例：
package test.z.udp;
import org.jkas.core.UdpService;
import java.net.DatagramPacket;
import java.util.HashMap;
import java.io.IOException;
public class MyUdp extends UdpService
{ private boolean hasHandshake=false;
public MyUdp()
{
}
   public void OnMessage(DatagramPacket packet,byte[] message)
{String msg="";
try { msg=new String(message);
        }catch(Exception e)
  {msg=e.toString();
  }
  usend("goods"+msg);
}
}

三、UDP广播/多播

1、广播
广播地址是专门用于同时向网络中所有工作站进行发送的一个地址。在使用TCP/IP 协议的网络中，主机号为全1的IP地址为广播地址。例如，对于 :192.168.199.0(掩码:255.255.255.0)网段，其广播地址为192.168.199.255 （255 即为2进制的11111111 ），当发出一个目的地址为192.168.199.255的分组时，它将被分发给该网段上的所有计算机。
1.1 直接广播地址
指Host部分全为1的广播地址。如：192.168.199.255。当某机器发出目的地址为直接广播（如：192.168.199.255）时，路由器通过查找路由表可以转发，直到该网段。
1.2 受限广播地址
也称本地广播地址，它不被路由发送，但会被送到相同物理网络段上的所有主机，IP地址的网络号和主机号全为1就是地址255.255.255.255，当某机器发出目的地址为本地广播时，路由器不会转发该包。所以该包只能限制在本网段
String udpbroadcast(String host,int port,byte[] msg)//host为广播地址，port为广播端口、msg为广播内容，返回1为广播成功，返回其他为失败原因
String udpbroadcast(String host,int port,String msg)

2、多播
IP 多播通信必须依赖于 IP 多播地址，在 IPv4 中它是一个 D 类 IP 地址，范围从 224.0.0.0 到 239.255.255.255，并被划分为局部链接多播地址、预留多播地址和管理权限多播地址三类：
1）局部链接多播地址范围在 224.0.0.0~224.0.0.255，这是为路由协议和其它用途保留的地址，路由器并不转发属于此范围的IP包；
2）预留多播地址为 224.0.1.0~238.255.255.255，可用于全球范围（如Internet）或网络协议；
3）管理权限多播地址为 239.0.0.0~239.255.255.255，可供组织内部使用，类似于私有 IP 地址，不能用于 Internet，可限制多播范围。
String multibroadcast(String host,int port,byte[] msg)//host为组播地址，port为广播端口、msg为广播内容，返回1为广播成功，返回其他为失败原因
String multibroadcast(String host,int port,String msg)

四、UDP 客户端

1、配置
[UDP CLIENT]
;for client 是否开启服务器主动请求一个外部udp
udp_client_enable=1
;要请求的外部主机地址
udp_client_host=localhost
;要请求的外部主机端口
udp_client_port=6666
;是否启用类覆盖
udp_client_override=0
;如果启用类覆盖，指定用来覆盖的类名，必须继承UdpClient
udp_client_class=test.z.udp.MyUdpClient
;外部主机响应后调用类的包名设置
udp_client_package=test.z.udp

2、信息回应与响应类，每次不能大于1024字节
void usendc(String content)//只能在响应类中调用
void usendc(byte[] content)//只能在响应类中调用
boolean ucsend(String content)//全局可调用
boolean ucsend(byte[] content)//全局可调用

外部机器请求发送数据格式：
{"app":"test","data":{"name":"sfsd"}}//其它请求，app指自己写的继承于JkasUdpClient的类，act:该类的方法，没传act默认为index
udp client响应类编写：
udp client类必须继承于JkasUdpClient，方法类型不限定，但最终会以字符串输出到客户端
获取前端参数,即data数据方法：
String D()//获取整个data数据
String D(String key)//获取json结构的data数据指定key的值
案例：
package test.z.udp;
import org.jkas.core.JkasUdpClient;
public class TestClient extends JkasUdpClient
{ public String index()
{ usendc("abcdefg");
   return "udp client";
}
}

响应输出：
{"code":404,"msg":"Bad Request"}//app或act名称不符要求
{"code":200,"msg":"success"}//收到非Json信息，不做任何处理
{"code":404,"msg":"Please set the package in the configuration file first."}//包名没配置输出
{"code":404,"msg":"notice messages"}//各种提示信息
{"code":500,"msg":"invalid json data"}//请求的JSON数据格式错误
如果是自定义类，字符串原样输出

3、自定义Udp Client
自定义udp client的类，必须继承UdpClient
并且要同时开启
udp_client_enable=1
udp_client_override=1
开启自定义udp client后，udp client响应类转发将失效

覆盖如下方法进行自定义类的实现，可以不全部覆盖：
public void OnMessage(DatagramPacket packet,byte[] message)//收到信息
public void OnError(DatagramPacket packet,String error)//出现错误
案例：
package test.z.udp;
import org.jkas.core.UdpClient;
import java.net.DatagramPacket;
public class MyUdpClient extends UdpClient
{
public MyUdpClient()
{
}
   public void OnMessage(DatagramPacket packet,byte[] message)
{String msg="";
try { msg=new String(message);
        }catch(Exception e)
  {msg=e.toString();
  }
  usendc("goods"+msg);
}
}
WEBSOCKET

JKAS WEBSOCKET

说明：如果开启了websocket,每次更新站点，需要重新启动容器（tomcat,resin......)，原因是已经开启端口的线程没有同时重启，端口占用异常，实例化不到对象

配置：
[WEBSOCKET]
#是否开启websocket 0为不开启，1为开启
ws_enable=1
#websocket端口，注意不要与其它已经使用端口冲突，端口可以通过nginx等反向从80端口代理过来
ws_port=8888
#websocket调用包名设置
ws_package=test.z.websocket

信息推送：每次不能大于1024字节
wsend(String messages)//推送到当前连接用户
wsend(byte[] messages)
wsend(String to,String messages)//通过websocket推送信息到指定用户 usertag:用户标识，前端登录时指定,多个用逗号隔开，messages:信息内容,注：仅可在定时任务、过滤器、监听器及控制器中使用
wsend(String to,byte[] messages)
前端请求发送数据格式：
{"cmd":"close"}//关闭
{"cmd":"login","uid":"zhou886"}//登录
{"app":"test","data":{"name":"sfsd"}}//其它请求，app指自己写的继承于Websocket的类，act:该类的方法，没传act默认为index

websocket类编写：
websocket类必须继承于Websocket，方法类型不限定，但最终会以字符串输出到客户端
获取前端参数,即data数据方法：
String D()//获取整个data数据
String D(String key)//获取json结构的data数据指定key的值
案例：
package test.z.websocket;
import org.jkas.core.Websocket;
public class Test extends Websocket
{ public String index()
{return D("name");
}
}

服务端输出：
{"code":200,"msg":"connected"}//连接成功
{"code":200,"msg":"login"}//登录成功
{"code":200,"msg":"closed"}//关闭连接成功
{"code":404,"msg":"Bad Request"}//app或act名称不符要求
{"code":200,"msg":"success"}//收到非Json信息，不做任何处理
{"code":404,"msg":"Please set the package in the configuration file first."}//包名没配置输出
{"code":404,"msg":"notice messages"}//各种提示信息
{"code":500,"msg":"invalid json data"}//请求的JSON数据格式错误
如果是自定义类，字符串原样输出

客户端：
<html>
<head>
</head>
<body>
<div id="valueLabel">ddddd</div>
<input id="speak" />
<input type="button" onclick="say()" value="send"/>
<input type="button" onclick="closews()" value="Close" style="display:none;" id="closebtn"/>
<input type="button" onclick="connws()" value="Connection" id="connbtn" style="display:inline"/>
<input type="button" onclick="loginws()" value="Login" id="loginbtn" style="display:inline"/>
<script type="text/javascript">
var socket;
var speak=document.getElementById("speak");
var valueLabel = document.getElementById("valueLabel");

function connws() {
valueLabel.innerHTML = "";
document.getElementById("closebtn").style.display="inline";
document.getElementById("connbtn").style.display="none";
var ws = new WebSocket("ws://127.0.0.1:9999");

ws.onmessage = function(evt) {

valueLabel.innerHTML = valueLabel.innerHTML + " " + evt.data;

};

ws.onclose = function(evt) {

valueLabel.innerHTML = "onClose";
document.getElementById("connbtn").style.display="inline";
document.getElementById("closebtn").style.display="none";

};

ws.onopen = function() {

ws.send("Hello, Jkas");

};

socket = ws;

}

function say()

{

socket.send(speak.value);

}

function closews()
{socket.send('{"cmd":"close"}');
}

function loginws()
{socket.send('{"cmd":"login","uid":"zhou666"}');
}

</script>
</body>
</html>

服务器端：
wsend("zhou886","I love you!");
RPC

JKAS RPC

RPC（Remote Procedure Call Protocol）远程过程调用协议，通过网络从远程计算机上请求调用某种服务。它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。
一、配置
[RPC]
;是否启用RPC
rpc_enable=1
;RPC服务所在包名
rpc_package=test.z.rpc
;RPC端口
rpc_port=9889

二、服务命名
服务由接口文件和实现文件构成
命名方式为服务名可自行命名，遵循驼峰命名规则
实现名由服务接口名+Impl方式命名

如：
Hello为服务接口名
HelloImpl为服务实现命名

三、案例
1、服务端
package test.z.rpc;
public interface Hello {
    String sayHello(String string);
}

package test.z.rpc;
public class HelloImpl implements Hello{

    public String sayHello(String string) {
        // TODO Auto-generated method stub
        return "你好:" + string;
    }
}

2、客户端（只支持JAVA)
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;

import test.z.rpc.Hello;

public class RpcClient<T> implements InvocationHandler {
    private Socket socket = null;
ObjectOutputStream output = null;
    ObjectInputStream input = null;
    private Class<T> serviceInterface;
    private InetSocketAddress addr;

    public RpcClient(String ip,String port) {

        this.addr = new InetSocketAddress(ip, Integer.parseInt ( port ));
    }

    public T getClientIntance(Class<T> serviceInterface){
        this.serviceInterface = serviceInterface;
  return (T) Proxy.newProxyInstance (serviceInterface.getClassLoader(),new Class<?>[]{serviceInterface},this);
    }
public void conn()
{ try {
            socket = new Socket();
            socket.connect(addr);
       }
    catch(Exception e)
  {
  }
}
public void close()
{try{

   if (socket != null) socket.close();
   if (output != null) output.close();
         if (input != null) input.close();
     }
  catch(Exception e)
  {
  }
}

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            conn();
            output = new ObjectOutputStream(socket.getOutputStream());
            output.writeUTF(serviceInterface.getName());
            output.writeUTF(method.getName());
            output.writeObject(method.getParameterTypes());
            output.writeObject(args);
            input = new ObjectInputStream(socket.getInputStream());
            return input.readObject();
        } finally {
           close();
        }
    }

    public static void main(String[] args) {
        RpcClient client = new RpcClient<>("localhost","9889");
        Hello hello = (Hello) client.getClientIntance (Hello.class);
        System.out.println (hello.sayHello ( "socket hellorpc" ));
    }
}
RMI

JKAS RMI

RMI（Remote Method Invocation）远程方法调用。能够让在客户端Java虚拟机上的对象像调用本地对象一样调用服务端java 虚拟机中的对象上的方法
一、配置
[RMI]
;是否启用RMI
rmi_enable=1
;RMI服务所在包名
rmi_package=test.z.rmi
;RMI主机地址
rmi_host=localhost
;RMI端口
rmi_port=9888

二、服务命名
服务由接口文件和实现文件构成
接口文件必须继承JkasRmi接口
命名方式为服务名可自行命名，遵循驼峰命名规则
实现名由服务接口名+Impl方式命名

如：
Hello为服务接口名
HelloImpl为服务实现命名

三、配置服务表
服务表文件位置：data/rmitab
所有服务名必须写入服务文件rmitab,每行一个
如：
Hello
Test

四、案例
1、服务端
package test.z.rmi;
import java.rmi.RemoteException;
import org.jkas.core.JkasRmi;
public interface Hello extends JkasRmi {
    public String sayHello(String str) throws RemoteException;
}

package test.z.rmi;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloImpl extends UnicastRemoteObject implements Hello {
    public HelloImpl() throws RemoteException {
        super();
    }
    public String sayHello(String str) throws RemoteException {
        return "Hello，" + str + "!";
    }
}

2、客户端（只支持JAVA)
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import test.z.rmi.Hello;
public class Client {
    public static void main(String args[]) {
        try {
            // 填写服务器ip
            Hello hello = (Hello) Naming.lookup("rmi://localhost:9888/Hello");
            System.out.println(hello.sayHello("Hello"));
        } catch (NotBoundException e) {
   System.out.println(e.toString());
        } catch (MalformedURLException e) {
            e.printStackTrace();
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}
邮件发送

Jkas 邮件发送

String mail(String to,String subject,String content)
          String mail(String to,String subject,String content,String fromname)
               String mail(String to,String subject,String content,String fromname，String attachment1,String attachment2,...)//可以发送多个附件，附件为文件的绝对路径
           /*参数说明
              to:收件人邮箱地址
              subject：邮件主题
              content：邮件文本内容
              fromname：发件人名称
              attachment：附件文件绝对路径
            */
服务层

Jkas 服务层

非必须，可根据开发需要用或不用服务层。
继承于org.jkas.core.S,处理模型的数据，并与控制进行交互，根据需求是否需要使用该层，该层不能使用控制器专用方法
控制器
基础入门

Jkas 控制器入门

步骤
1、包导入：
import org.jkas.core.C;

2、继承C
public class Test extends C {
}

3、初始化方法为init()//返回false将不再继续执行action
public class Test extends C {
public boolean init()
     {//初始操作
       return true;
      }
}

4、写相应的action，系统保留方法：start，init,release,destroy,如果有这些方法，系统将直接转到index方法
public class Test extends C {
public boolean init()
     {//初始操作
        return true;
      }

public void index()
{ echo("welcome to jkas!");//实现业务逻辑
}
}

5、释放全局变量方法release()
public class Test extends C {
public void release()
     {//释放操作
      }
}
请求支持

Jkas 请求支持

请求头Content-Type支持类型：
1、application/x-www-form-urlencoded
普通get或post

2、multipart/form-data
带文件上传及参数表单方式提交，只支持POST请求情况

3、application/json
支持JSON格式提交请求，会把第一层JSON对象键值放入参数对象，可以用P(键名)读取出参数值，多层会把下面层作为字符串传入

4、application/xml
支持XML格式提交请求，只支持一级XML格式，如果存在二级，会把二级的拼成一个字符串，不建议有二级
提交XML格式必须遵循XML标准：
如下：
<?xml version="1.0" encoding="UTF-8"?>
<data>
<to>Jkas</to>
<from>Joe</from>
<heading>Miss You</heading>
<body>Don't forget the meeting!</body>
</data>
专用方法

Jkas 控制器专用方法

控制器专用方法
以下所有方法必须继承于org.jkas.core.C方能调用

1、系统
boolean init();//初始化方法返回false不继续执行action
void ec ho(String str)
void echo(byte[] data)
void ec ho(Object obj)//以字符串输出对象
void ec ho(Object obj1，Object obj2,Object obj3,...,Object objn)//以字符串输出对象
void echo(int num)
void echojson(int code,String data)
void echojson(int code,String data,String msg)
void setStatus(int status)//设置HTTP响应状态码，状态码说明见附件HTTP状态码
void sendError(int status,String errors)//向用户发HTTP响应状态码及信息，状态码说明见附件HTTP状态码
String serverInfo()//获取容器名称及版本，如：Resin/4.0.51
String getApp() 返回控制器
String getAct() 返回请求方法
String webRoot() 网站根域名
String rootPath() 网站根目录
int getRequestCount() //当前请求数量
int getSessionCount() //当前访问用户数量
Object application(String key)//读取全局变量，应用级别，定时任务、过滤器、监听器也支持该方法
boolean application(String key,Object obj)//写全局变量，应用级别，定时任务、过滤器、监听器也支持该方法，obj为null时删除变量
boolean applicationdrop(String key)//删除全局变量
如：
echo("jkas");
echo(1);

2、用户请求/响应
HashMap<String,String> p()//取出所有提交参数
boolean Phas(String key)//是否存在参数
String P(String parametername)//根据参数名获取提交参数
String P(String parametername, String defautvalue )//根据参数名获取提交参数，如果参数不存在，则返回默认值
String Ptrim(String parametername)//去除前后空格
String Pescape(String parametername)//获取经过escape编码后的参数
String Phtml(String parametername)//获取经过HTML转义后的参数
String Punhtml(String parametername)//获取参数并去掉参数的HTML标签
String Plow(String parametername)//全部转为小写字母
String Pup(String parametername)//全部转为大写字母
int Pint(String parametername);//把参数自动转为整数返回
long Plong(String parametername);//把参数自动转为长整数返回
int Pfloat(String parametername);//把参数自动转为浮点数返回
int Pdouble(String parametername);//把参数自动转为双精度数返回
String Ptrim(String parametername, String defautvalue )//去除前后空格，如果能数不存在，则返回默认值
String Pescape(String parametername, String defautvalue )//获取经过escape编码后的参数，如果参数不存在，则返回默认值
String Phtml(String parametername, String defautvalue )//获取经过HTML转义后的参数，如果参数不存在，则返回默认值
String Punhtml(String parametername, String defautvalue )//获取参数并去掉参数的HTML标签，如果参数不存在，则返回默认值
String Psafehtml(String p)//去除不安全的html标签<script>、<img>等均去除
String Psafehtml(String p,String v)//去除不安全的html标签，如果参数不存在，则返回默认值
String Psafeimghtml(String p)//保留<img>标签，去除不安全的html标签<script>等均去除
String Psafeimghtml(String p,String v)//保留<img>标签，去除不安全的html标签<script>等均去除，如果参数不存在，则返回默认值
String Pcleanhtml(String p)//去除所有HTML标签
String Pcleanhtml(String p,String v)//去除所有HTML标签，如果参数不存在，则返回默认值
String Preplace(String p,String str,String newstr)//获取参数值并把str替换成newstr
String Preplace(String p,String str,String newstr,String v)//获取参数值并把str替换成newstr，如果参数不存在，则返回默认值
String Plow(String parametername, String defautvalue )//全部转为小写字母，如果参数不存在，则返回默认值
String Pup(String parametername, String defautvalue )//全部转为大写字母，如果参数不存在，则返回默认值
int Pint(String parametername, int defautvalue );//把参数自动转为整数返回，如果参数不存在，则返回默认值
long Plong(String parametername, long defautvalue );//把参数自动转为长整数返回，如果参数不存在，则返回默认值
int Pfloat(String parametername, float defautvalue );//把参数自动转为浮点数返回，如果参数不存在，则返回默认值
int Pdouble(String parametername, double defautvalue );//把参数自动转为双精度数返回，如果参数不存在，则返回默认值
String[] Parr(String parametername);//把参数用逗号分隔成字符数组
String[] Parr(String parametername,String c);//把参数用字符c分隔成字符数组
HashMap<String,String> P()//返回所有参数
ArrayList<HashMap<String,String>> FILES() //用户上传文件列表
HttpServletRequest getRequest() //获得request对象
HttpServletResponse getResponse() //获取reponse对象
long contentLength() 为请求总大小
boolean IS_POST() | boolean isPost()//是否POST请求
boolean IS_GET() | boolean isGet() //是否GET请求
boolean IS_PUT() | boolean isPut()//是否PUT请求
boolean IS_PATCH() | boolean isPatch()//是否PATCH请求
boolean IS_DELETE() | boolean isDelete()//是否DELETE请求
boolean IS_HTTPS() | boolean isHttps()//是否是https请求
String clientIp()//获取客户端IP
String clientIp(String headerName)//获取自定义转发的IP,headerName为自定义的IP转发请求头名称
String serverIp()//获取服务器IP
OutputStream getOutputStream()//获取输入流对象
InputStream getInputStream()//获取输入流对象
byte[] getInputByte()//返回输入流数据
ByteArrayOutputStream getInputByte()//返回输入流转ByteArray输出流
String getInputString()//输入流转字符串
String getRequestHost()//获取请求主机地址或域名
int getRequestPort()//获取请求主机端口
String getRequestScheme()//获取请求的协议
String getRequestUrl()//获取请求Url,带有域名，含参数
String getRequestUri()//获取请求文件路径，没有域名，含参数
String getRequestPath()//获取请求文件路径，没有域名，不含参数
String getQueryString()//获取请求参数部分
String header(String headerName)//获取来自客户端的请求头
HashMap<String,String> headers()//获取来自客户端的所有请求头
void header(String key,String value)//设置响应头
void header(HashMap<String,String> params)//批量设置响应头
String getContextParam(String key)//读取web.xml配置文件中<context-param>标签下的初始参数
HashMap<String,String> getContextParams()//读取web.xml配置文件中<context-param>标签下的所有初始参数

如：
String a=P("a");
HashMap<String,String> P();//返回所有用户请求参数

3、sess ion
1）、session 读取
HashMap<String,Object> sessions() 读取当前用户所有session数据
T sess(String key)//T为返回类型，返回类型必须是对象，不能是8种基本类型（切记），如果使用，要自行处理异常。
Object session(String key);//以对象形势获取session
String sess2str(String key);//以字符串形势获取session
int sess2int(String key);//以整数形式获取session
long sess2long(String key);//以长整数形式获取session
float sess2float(String key);//以浮点数形式获取session
double sess2double(String key)//以双精度数形式获取session
String sessionid()//读取session id
long sessionCreateTime()//读取session 创建时间
long sessionLastTime()//读取session最后访问时间

2）、session 写
void session(String key,Object value)
session删除把值设为null,如:session("a",null);
void sessdel(String key)//删除指定session
void sessdel();//清空session

3）、自定义session机制，用于自行扩展，如负载集群中的session共享，或监听session的变化等
必须在配置文件中设置好：
[SESSION]
;开启自定义
session_override=1
；指定自定义类，该类必须继承于JkasSession
session_class=test.z.session.MySession

配置完成后，编写该类，覆盖父类的方法完成自定义session机制，如：
package test.z.session;
import org.jkas.core.JkasSession;
public class MySession extends JkasSession
{ public MySession()
{
}
public String getId()
{return super.getId();
}
}

可以覆盖的方法如下，可以只覆盖需要的部分方法，不一定要全部覆盖，可以通过super.方法名调用这些方法：

public Object getAttribute(String name)
{
}
public Enumeration<String> getAttributeNames()
{
}
public long getCreationTime()
{
}
public String getId()
{
}
public long getLastAccessedTime()
{
}
public int getMaxInactiveInterval()
{
}
public ServletContext getServletContext()
{
}
public void invalidate()
{
}
public boolean isNew()
{
}
public void removeAttribute(String name)
{
}
public void setAttribute(String name,Object value)
{
}
public void setMaxInactiveInterval(int interval)
{
}

4、coo kie
1）、cookie 读
HashMap<String,String> cookies()//读出所有cookie为HashMap格式
String cookie(String key)//读出指定键的cookie

2）、cookie 写
void cookie(String key,String value)//设置cookie 默认时间为30000秒；默认路径为“/”
void cookie(String key,String value,int expired)//默认路径为/
void cookie(String key,String value,int expired,String path)
cookie删除把值设置为null或把过期时间设置为0即可
void cookiedel(String key)//删除指定cookie

5、语言获取
String L(String lankey)

6、u rl编码
String url(String url);
String url(String url,String params);
String url(String app,String act,HashMap<String,String>params)
String url(String module,String app,String act,HashMap<String,String>params)//开启模块方式后使用该方式

7、URL重定向
1)、服务端转发（url不变);
void forw ard(String url);
2)、客户端转发(url改变）；
void redir ect(String url);

8、资源引入
String imports(String type,String res)//type为资源类型，值为：css,js,libcss,libjs，返回包括HTML标签
String url(String type,String res);//type为资源类型，值为：css,js,libcss,libjs，返回完整URL路径
String img(String res)//返回完整图片路径
当配置文件配置了相应资源的域名时，返回的路径将按指定的域名返回！
模型

模型介绍

模型类命名方式均以大写M结尾

一、如何开始
       1、导入类
       import org.jkas.core.M;


      2、继承类
        class MemberM extends M
       {
             public MemberM()
               { setTable（"members"）;//模型对应表名(非必须)，不设置默认为模型名称
                 setAlias("m");//表的别名(非必须),在join或where条件时，可以对长表名进行别名简写
                 primaryKey("member_id");//对应表主键（必须）
                 setSource("datasourcename");//(非必须),使用指定数据源,不指定将按框架配置的数据源默认操作，使用该方法必须在resin、tomcat等容器中配置好数据源，目的是实现不同模型操作不同数据库
               }
       }

       3、实例化并使用
        MemberM m=new MemberM();
        String tablename=m.tablename();

     4、SQL语句调试
        String toSql(String action);//action 为：select update delete insert
         输出最终的SQL语句

查询

一、简单查询

（优点：执行性能高效，缺点：SQL要全部自己写）

实例化：

Member m=new Member();

1、ArrayList<HashMap> select(String sql)

ArrayList<T> select(String sql,Class<T> t)//T是数据实体JavaBean,参数假设是类UserBean,则传参为UserBean.class，见下面案例

ArrayList<B> select2b(String sql)//反回实体B,org.jkas.core.B 通过get("属性名")方法获取属性值

String selectJson(String sql)//返回Json格式数据

如：

普通查询案例：

m.select("select * from "+m.tablename());//m.select()等效

使用实体Bean查询案例：

实体Bean：

package test.z.beans;
public class UserBean{
    private int id;
    private String username;
private String password;
private int sex;

public int getId()
{return this.id;
}
    public String getUsername()
{return this.username;
}

public int getSex()
{return this.sex;
}

public String getPassword()
{return this.password;
}

public void setId(int id)
{this.id=id;
}

public void setSex(int sex)
{this.sex=sex;
}

public void setPassword(String password)
{this.password=password;
}

public void setUsername(String username)
{this.username=username;
}

}

控制器里面这样写：

public void beanquery()
{UserM um=new UserM();
     ArrayList<UserBean> ublist=um.select(UserBean.class);
for(UserBean ub:ublist)
  {echo("id:",ub.getId(),"username:",ub.getUsername(),"<br/>");
  }
}

2、String getOne(String sql)//查询一个字段

3、HashMap<String,String> getRows(String sql)//查询一行

T getRows(String sql,Class<T> t)//T为实体Bean类

B getRows2b(String sql)//返回B为实体

String getRowsJson(String sql)//查询一行，返回Json格式数据

4、HashMap<String,Object> getRowsObj(String sql);//查询一行，对象返回

5、ArrayList<String> getCols(String sql)//查询一列

ArrayList<B> getCols2b(String sql)

ArrayList<T> getCols(String sql,Class<T> t)//T为实体Bean类

String getCols(String sql)//查询一列，返回Json格式数据

6、HashMap<String,String> get(int prikey)//根据主键获取单条信息

T get(int prikey,Class<T> t)//T为实体Bean类

B get2b(int prikey)//B为实体类

String getJson(int prikey)//根据主键获取单条信息Json格式数据

7、HashMap<String,String> getInfo(Object prikey)//根据主键获取单条信息

T getInfo(Object prikey,Class<T> t)//根据主键获取单条信息到实体Bean

B getInfo2b(int prikey)//根据主键获取单条信息到实体B

String getInfoJson(Object prikey)//根据主键获取单条信息Json格式数据

8、HashMap<String,Object> getInfoObj(Object prikey)//根据主键获取单条信息，对象返回

9、JkasResult rs(String sql)//返回JkasResult(和ResultSet一样)对象，效率最高

案例：

UserM um=new UserM();
   JkasResult jr=um.where("id<3").rs();
    if(jr!=null)
  {try{
     while(jr.next())
   {echo(jr.getString(1),jr.getString(2),jr.getString(3));
   }
       }catch(Exception e){}
  }

10、selectCount(String sql)//获取符合条件的记录数

二、简化查询

（优点：SQL自动生成，缺点：性能会有所损耗）

Member m=new Member();

1、m.table("test").fields("a,b,c").where("a>1").and("c=1").or("b=2").order("a desc").order("b asc").limit("1,10").count().select();

2、m.getCount();//返回符合条件的总记录，必须在执行查询时带count()函数才会有值

3、简化方法介绍

source(String datasource)//指定数据源，只针对当前查询有效，目的对不同数据库进行操作

as(String alias)//当前表别名，只针对当前查询有效

fields(String field)

values(Object value1,Object value2,...)

and(String where)

and(String field,String operator,Object value)

or(String where)

or(String field,String operator,Object value)

where(String where)

where(String where,String relation)

where(String field,String operator,Object value)//预处理情况不要使用这个

where(String field,String operator,Object value,String relation)//operator:> < =, relation:and or；预处理情况不要使用这个

in(String field,Object value1,Object value2,...)

orin(String field,Object value1,Object value2,...)

notin(String field,Object value1,Object value2,...)

ornotin(String field,Object value1,Object value2,...)

inall(String field,String values)

orinall(String field,String values)

notinall(String field,String values)

ornotinall(String field,String values)

between(String field,Object value1,Object value2)

orbetween(String field,Object value1,Object value2)

notbetween(String field,Object value1,Object value2)

ornotbetween(String field,Object value1,Object value2)

order(String sort)

limit(int position,int count)

table(String table)

join(String table)

join(String table,String lk,String rk)

join(String table,String lk,String rk,String type)//type:inner,left,right

join(String table,String lk,String rk,String onext,String type)//在默认指定外键基础上，追加多个条件时使用，采用and条件

on(String onext)//在默认指定外键基础上，追加多个条件时使用，采用and条件

oron(String onext)//在默认指定外键基础上，追加多个条件时使用，采用or条件

union(String table,String fields,String where)//where为union表的条件

unionall(String table,String fields,String where)

count()

preCount(Object... params)//预处理时用

count(String field)

preCount(String field,Object... params)//预处理时用

String getOne();

ArrayList<HashMap> select();

String selectJson();

T ArrayList<T> select(Class<T> t);

ArrayList<B> select2b()

HashMap<String,String> getRows();

String getRowsJson();

B getRows2b()

T getRows(Class<T> t);

HashMap<String,Object> getRowsObj();

ArrayList<String> getCols();

String getColsJson();

ArrayList<B> getCols2b()

ArrayList<T> getCols(Class<T> t);

JkasResult rs();//返回ResultSet对象

int selectCount();//返回记录数

int records();//返回记录数

int records(String field)//返回count(field)记录数

三、另类查询

（大量数据情况下效率会高，分开两个部分，减少HashMap的操作时间）

DbResults select2(String sql)//返回DbResults 对象

DbResults select2();

DbResults prepareSelect2(String sql,Object param1,Object param2,...)

DbResults prepareSelect2(HashMap<Integer,Object>);

DbResults prepareSelect2(Object param1,Object param2,...)

DbResults 对象方法：

HashMap<String,Integer> getRows()//获取全部字段名

ArrayList<String[]> getCols()//获取查询记录

String get(String colname)//获取第一条记录的对应列名的值

String get(int colnum,String colname)//获取第colnum条记录对应列名的值

四、查询分页

1、导入分页类

import org.jkas.utils.Page;

2、分页操作

Page( int page, int pagenum);//page:当前页；pagenum:每页显示数；实例构造函数

void setDisplayPages(int num)//设置显示页码条数

void setCount(int count)//设置总记录数

HashMap<String,Integer> getInfo()//获取分页信息

String getInfoJson()//获取Json格式分页信息

分页信息结构：

pages：总页

s:页码起始数

e:页码终止数

pos：记录当前页起始位置

count:总记录数

page:当前页

pre:上一页，为0时表示没有了

next:下一页，为0时表示没有了

pagenum:每页显示记录条数

例子：

Users u=new Users();
  int pagenum=10;
  int page=Pint("page");
Page p=new Page(page,pagenum);
  ArrayList<HashMap> users=u.count().limit(p.getPos(),pagenum).select();
  p.setCount(u.getCount());
  assign("users",users);
  assign("pageinfo",p.getInfo());

增加

jkas 数据增加操作

一、简单新增
int query(String sql)

二、简化新增
Member m=new Member();
m.fields("a,b,c,d").values(1,2,3,"kk").insert();
m.fields("a,b,c,d").insert(Object value1,Object value2,...);//value不用加单引号
m.fields("a,b,c,d").values(1,2,3,4).replace();
m.insert(HashMap<String key,Object value>);//不能把自增主键加入，推荐
m.insert(Object bean);//bean为实体bean,不能把自增主键加入；效率低，不建议用

m.fields("a,b,c,d").values(1,2,3,"kk").replace();
更新

jkas 数据更新操作

一、简单更新
int query(String sql)

二、简化更新
set(String field)//专用于更新操作如 m.where("id=2).set("a=1,b='k'").update();
set(String fields,Object value1,Object value2,...);//专用于更新操作如 m.where("id=2).set("a,b",1,"k").update();

Member m=new Member();
m.set("a=1,b=2,c=3,d='k'").where("a>0").update();//注意字符串要加单引号
m.where("id=2).set("a,b",1,"k").update();//字符串不需要加
m.where("a=1").update(HashMap<String key,Object value>);
m.update(HashMap<String key,Object value>);注意模型必须设置主键primaryKey("member_id")；
m.update("a=1",HashMap<String key,Object value>);
m.fields("a,b,c").value(1,2,"kk").update()
m.fields("a,b,c").update(Object value1,Object value2,...)
m.update(Object bean);//bean为实体bean,注意模型必须设置主键primaryKey("member_id")；
m.update("a=1",Object bean);//bean为实体bean,注意默认值和主键，必须都要赋值；
m.where("a=1").update(Object bean);//bean为实体bean,注意默认值和主键，必须都要赋值；
删除

数据记录删除

一、简单删除
int query(String sql)

二、简化删除
Member m=new Member();
m.where("a>1").delete();
m.delete("a=1");

三、清空
int clear()//整张表清空，慎用
Member m=new Member();
m.clear();
预处理
一、数据记录查询
1、简单查询
- ArrayList<HashMap> prepareSelect(String sql,HashMap<Integer,Object> params)；
- ArrayList<HashMap> prepareSelect(String sql,Object param1,Object param2,...)
- String prepareSelectJson(String sql,HashMap<Integer,Object> params)；
- String prepareSelectJson(String sql,Object param1,Object param2,...)
- ArrayList<B> prepareSelect2b(String sql,HashMap<Integer,Object> params)；
- ArrayList<B> prepareSelect2b(String sql,Object param1,Object param2,...)
- ArrayList<T> prepareSelect(String sql,HashMap<Integer,Object> params,Class<T> t)；
- ArrayList<T> prepareSelect(String sql,Class<T> t,Object param1,Object param2,...)
- String prepareOne(String sql,HashMap<Integer,Object> params)
- String prepareOne(String sql,Object param1,Object param2,...)
- HashMap<String,String> prepareRows(String sql,HashMap<Integer,Object> params)
- HashMap<String,String> prepareRows(String sql,Object param1,Object param2,...)
- String prepareRowsJson(String sql,HashMap<Integer,Object> params)
- String prepareRowsJson(String sql,Object param1,Object param2,...)
- B prepareRows2b(String sql,HashMap<Integer,Object> params)
- B prepareRows2b(String sql,Object param1,Object param2,...)
- T prepareRows(String sql,HashMap<Integer,Object> params,Class<T> t)
- T prepareRows(String sql,Class<T> t,Object param1,Object param2,...)
- HashMap<String,Object> prepareRowsObj(String sql,HashMap<Integer,Object> params)
- HashMap<String,Object> prepareRowsObj(String sql,Object param1,Object param2,...)
- ArrayList<String> prepareCols(String sql,HashMap<Integer,Object> params)
- ArrayList<String> prepareCols(String sql,Object param1,Object param2,...)
- String prepareColsJson(String sql,HashMap<Integer,Object> params)
- String prepareColsJson(String sql,Object param1,Object param2,...)
- ArrayList<B> prepareCols2b(String sql,HashMap<Integer,Object> params)
- ArrayList<B> prepareCols2b(String sql,Object param1,Object param2,...)
- ArrayList<T> prepareCols(String sql,Class<T> t,HashMap<Integer,Object> params)
- ArrayList<T> prepareCols(String sql,Class<T> t,Object param1,Object param2,...)
JkasResult preRs(String sql,Object param1,Object param2,...)//返回ResultSet对象，效率最高
int preSelectCount(String sql,Object param1,Object param2,...)//返回记录数

2、简化查询（T代表实体Bean类）
- ArrayList<HashMap> prepareSelect(HashMap<Integer,Object> params)；
- ArrayList<HashMap> prepareSelect(Object param1,Object param2,...)
- String prepareSelectJson(HashMap<Integer,Object> params)；
- String prepareSelectJson(Object param1,Object param2,...)
- ArrayList<B> prepareSelect2b(HashMap<Integer,Object> params)；
- ArrayList<B> prepareSelect2b(Object param1,Object param2,...)
- ArrayList<T> prepareSelect(HashMap<Integer,Object> params,Class<T> t)；
- ArrayList<T> prepareSelect(Class<T> t,Object param1,Object param2,...)
Member m=new Member();
HashMap<Integer,Object> params=new HashMap<Integer,Object>();
params.put(1,1);
m.where("a>？").prepareSelect(params);
- String prepareOne(HashMap<Integer,Object> params)
- String prepareOne(Object param1,Object param2,...)
- HashMap<String,String> prepareRows(HashMap<Integer,Object> params)
- HashMap<String,String> prepareRows(Object param1,Object param2,...)
- String prepareRowsJson(HashMap<Integer,Object> params)
- String prepareRowsJson(Object param1,Object param2,...)
- T prepareRows(HashMap<Integer,Object> params,Class<T> t)
- T prepareRows(Class<T> t,Object param1,Object param2,...)
- HashMap<String,Object> prerpareRowsObj(HashMap<Integer,Object> params)
- HashMap<String,Object> prerpareRowsObj(Object param1,Object param2,...)
- ArrayList<String> prepareCols(HashMap<Integer,Object> params)
- ArrayList<String> prepareCols(Object param1,Object param2,...)
- String prepareColsJson(HashMap<Integer,Object> params)
- String prepareColsJson(Object param1,Object param2,...)
- ArrayList<T> prepareCols(HashMap<Integer,Object> params,Class<T> t)
- ArrayList<T> prepareCols(Class<T> t,Object param1,Object param2,...)
- preCount(Object... params)//预处理
- preCount(String field,Object... params)
- int preRecords(Object... params);//返回记录数
  int preRecords(String field,Object... params)//返回count(field)记录数
JkasResult preRs(Object param1,Object param2,...)//返回JkasResult(和ResultSet一样)对象，效率最高
案例：
UserM um=new UserM();
   JkasResult jr=um.where("id<?").preRs(5);
    if(jr!=null)
  {try{
     while(jr.next())
   {echo(jr.getString(1),jr.getString(2),jr.getString(3));
   }
       }catch(Exception e){}
  }

int preSelectCount(Object param1,Object param2,...)//返回记录数
二、数据插入

1、简单插入
int prepareQuery(String sql,HashMap<Integer,Object> params)
int prepareQuery(String sql,Object param1,Object param2,...)
2、简化插入
int fields("a,b,c").values(1,2,"k").prepareInsert();
int fields("a,b,c").values(1,2,"k").prepareReplace();
int fields("a,b,c").prepareInsert(HashMap<Integer,Object> params)
int fields("a,b,c").prepareInsert(Object param1,Object param2,Object param3,...)
int fields("a,b,c").prepareReplace(Object param1,Object param2,Object param3,...)
int prepareMapInsert(HashMap<String key,Object value> params)
int prepareReplace(HashMap<Integer,Object> params)
Member m=new Member();
HashMap<Integer,Object> params=new HashMap<Integer,Object>();
params.put(1,1);
m.fields("a").values("?").prepareInsert(params);
或
m.fields("a,name").values("?,?").prepareInsert(1,"zhou");

三、数据更新

1、简单更新
int prepareQuery(String sql,HashMap<Integer,Object> params)
int prepareQuery(String sql,Object param1,Object param2,...)
2、简化更新
int prepareUpdate(HashMap<Integer,Object> params)
int fields("a,b,c").values(1,2,"kk").prepareUpdate()
int fields("a,b,c").prepareUpdate(Object param1,Object param2,...)
int prepareMapUpdate(HashMap<String key,Object value> params)
int prepareUpdate(String where,HashMap<String key,Object value> params)
Member m=new Member();
HashMap<Integer,Object> params=new HashMap<Integer,Object>();
params.put(1,1);
m.set("a=?").prepareUpdate(params);

四、数据删除

1、简单删除
int prepareQuery(String sql,HashMap<Integer,Object> params)
int prepareQuery(String sql,Object param1,Object param2,...)
2、简化删除
int prepareDelete(HashMap<Integer,Object> params)
Member m=new Member();
HashMap<Integer,Object> params=new HashMap<Integer,Object>();
params.put(1,1);
m.where("a=?").prepareDelete(params);

五、数据批量处理

第1步：void prepares(String sql)；//预处理准备
第2步（以下其一操作，重复多次情况用）：预处理执行
ArrayList<HashMap> preparesSelect(HashMap<Integer,Object> params)
String preparesSelectJson(HashMap<Integer,Object> params)
ArrayList<T> preparesSelect(HashMap<Integer,Object> params,Class<T> t)
String preparesOne(HashMap<Integer,Object> params)
HashMap<String,String> perparesRows(HashMap<Integer,Object> params)
String perparesRowsJson(HashMap<Integer,Object> params)
T perparesRows(HashMap<Integer,Object> params,Class<T> t)
ArrayList<String> preparesCols(HashMap<Integer,Object> params)
String preparesColsJson(HashMap<Integer,Object> params)
ArrayList<T> preparesCols(HashMap<Integer,Object> params,Class<T> t)
int preparesQuery(HashMap<Integer,Object> params)
第3步：
void preparesClose()；//关闭所有资源（必须）
批量处理

数据批量处理

一、批量新增
int [] batchQuery(ArrayList<String> sqls)
int[] prepareBatchInsert(ArrayList<HashMap<Integer,Object>> params)
int[] prepareBatchReplace(ArrayList<HashMap<Integer,Object>> params)

二、批量更新
int [] batchQuery(ArrayList<String> sqls)
int[] prepareBatchUpdate(ArrayList<HashMap<Integer,Object>> params)

三、批量删除
int [] batchQuery(ArrayList<String> sqls)
int[] prepareBatchDrop(ArrayList<HashMap<Integer,Object>> params)
存储过程

一、权限设置

注：调用前要给用户赋予相应权限
过程：GRANT SELECT ON mysql.proc TO 'user'@'localhost';
函数：GRANT SELECT ON mysql.func TO 'user'@'localhost';

取消权限：REVOKE SELECT ON mysql.func from 'user'@'localhost'

二、方法函数

String call(String funname,HashMap<Integer,Object> params)；
如：
mysql存储方法：
DROP FUNCTION `myfun` ;

CREATE DEFINER = `root`@`localhost` FUNCTION `myfun` (
`a` INT,
`b` INT
) RETURNS INT( 11 ) NOT DETERMINISTIC CONTAINS SQL SQL SECURITY DEFINER BEGIN #Routine body goes here...
RETURN a + b;

END

java调用：
HashMap<Integer,Object> params=new HashMap<Integer,Object>();
    params.put(1,79);
    params.put(2,858);
    String a=m.call("myfun(?,?)",params);

三、存储过程

HashMap<Integer,Object> exec(String spname,HashMap<String,Object> params)；
如：
Mysql存储过程：
DROP PROCEDURE `myadd` ;

CREATE DEFINER = `root`@`localhost` PROCEDURE `myadd` ( IN `a` INT, IN `b` INT, OUT `c` INT, INOUT `d` INT ) NOT DETERMINISTIC CONTAINS SQL SQL SECURITY DEFINER BEGIN #Routine body goes here...
SELECT a + b
INTO c;

SELECT b + d
INTO d;

SELECT *
FROM jkas_members;

SELECT *
FROM jkas_test;

SELECT *
FROM jkas_user;

END

Java调用：
HashMap<String,Object> params=new HashMap<String,Object>();
    params.put("1",79);
    params.put("2",88);
    params.put("3>","integer");//>代表为输出参数，值为输出参数类型，类型见下面说明。
    params.put("4a","99ainteger");a代表为输入输出参数，a可以是除了数字和>的任意字符，但必须确保与值不重复；字符前表示输入值，字符后面表示输出类型，类型说明参见下面。
    HashMap<Integer,Object> a=m.ex ec("myadd(?,?,?,?)",params);
返回值说明：
0：ArrayList<ArrayList>//结果集，如果存储过程有结果集产生，则返回，有多个则返回多个
1~n:则是对应输出参数的值，参字符串形式返回

输出类型说明：
bigint
binary
bit
blob
char
clob
date
decimal
double
float
integer
java_object
longvarbinary
longvarchar
numeric
other
real
smallint
time
timestamp
tinyint
varbinary
varchar
事务处理

jkas 数据库事务操作

操作步骤（严格按照步骤,1、2，3、5，一步不能少）：

1、启动事务：
boolean transStart()
boolean transStart(String ISOLATION_LEVEL)//指定SESSION事务隔离级别，参数为：READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ、SERIALIZABLE
boolean transStart(Model ...models)//多个模型参与事务执行
boolean transStart(String ISOLATION_LEVEL,Model ...models)//指定SESSION事务隔离级别及多个模型参与事务执行

2、执行事务：
如果多个模型共同完成一个事务，其它模型需要调用用setTransConn(事务启动模型.getTransConn());
简单原始：
transQuery(String sql)
transBatchQuery(ArrayList<String> sqls)

简化操作：
int transInsert()
int transInsert(Object ...values)
int transInsert(HashMap<String,Object> params)
int transInsert(Object t)
int transInsert(String sqlkey,HashMap<String,Object> params)
int transReplace()
int transReplace(String sqlkey,HashMap<String,Object> params)
int transDrop()
int transDelete()
int transDelete(String where)
int transClear()
int transUpdate()
int transUpdate(HashMap<String,Object> params)
int transUpdate(Object ...values)
int objTransUpdate(Object ...values)
int transUpdate(String where,HashMap<String,Object> params)
int transUpdate(Object t)
int transUpdate(String where,Object t)

int transPreQuery(String sqlkey,HashMap<Integer,Object> params)
int transPrepareInsert(HashMap<Integer,Object> params)
int transPrepareMapInsert(HashMap<String,Object> params)
int[] transPrepareBatchInsert(ArrayList<HashMap<Integer,Object>> params)
int transPrepareReplace(HashMap<Integer,Object> params)
int[] transPrepareBatchReplace(ArrayList<HashMap<Integer,Object>> params)
int transPrepareUpdate(HashMap<Integer,Object> params)
int transPrepareMapUpdate(HashMap<String,Object> params)
int transPrepareUpdate(String where,HashMap<String,Object> params)
int[] transPrepareBatchUpdate(ArrayList<HashMap<Integer,Object>> params)
int transPrepareDrop(HashMap<Integer,Object> params)
int transPrepareDelete(HashMap<Integer,Object> params)
int[] transPrepareBatchDrop(ArrayList<HashMap<Integer,Object>> params)

3、提交事务
transCommit()

4、回滚事务（如果有异常,此步才需要）
transRollback()

5、结束事务
transEnd()
SQL分离

SQL分离介绍

实现SQL语句与模型分离，优势，支持所有类型数据库，不受框架分页功能（limit,只支持mysql）限制
sql(String sqlkey,HashMap<String,Object>),指定以自定义SQL方式进行数据库操作
sql(String sqlkey)//用于无参数或预处理情况

SQL分离配置

[DATABASE]
;开启自定义SQL语句功能
db_custom_sql=1
;配置自定义SQL文件所在目录，SQL自定义文件与模型指定的表名同名，以.m为后缀
db_custom_sql_dir=data/sql

SQL文件

SQL自定义文件与模型指定的表名同名，以.m为后缀

SQL文件内容采用键什对保存，SQL变量以"${"开头，以"}"结尾
注释以分号;开头，单独一行
如，user.m文件内容如下：
insertuser=insert into sc_user (username,password,sex) values('${username}','sdf',2)
;读取id小于指定变量的用户，这个用于预处理
getusers=select * from sc_user where id

查询

HashMap<String,String>sql(String sqlkey,HashMap<String,Object> params).get()
String sql(String sqlkey,HashMap<String,Object> params).getJson()
B sql(String sqlkey,HashMap<String,Object> params).get2b()
T sql(String sqlkey,HashMap<String,Object> params).get(Class<T> t)

HashMap<String,String>getInfo(String sqlkey,HashMap<String,Object> params)
String getInfoJson(String sqlkey,HashMap<String,Object> params)
B getInfo2b(String sqlkey,HashMap<String,Object> params)
T getInfo(String sqlkey,HashMap<String,Object> params,Class<T> t)

ArrayList<HashMap> select(String sqlkey,HashMap<String,Object> params)
String selectJson(String sqlkey,HashMap<String,Object> params)
ArrayList<T> select(String sqlkey,HashMap<String,Object> params,Class<T> t)
ArrayList<B> select2b(String sqlkey,HashMap<String,Object> params)

ArrayList<HashMap> sql(String sqlkey,HashMap<String,Object> params).select()
String sql(String sqlkey,HashMap<String,Object> params).selectJson()
ArrayList<T> sql(String sqlkey,HashMap<String,Object> params).select(Class<T> t)
ArrayList<B> sql(String sqlkey,HashMap<String,Object> params).select2b()

HashMap<String,Object> getInfoObj(String sqlkey,HashMap<String,Object> params)
HashMap<String,Object> sql(String sqlkey,HashMap<String,Object> params).getInfoObj()

String getOne(String sqlkey,HashMap<String,Object> params)
String sql(String sqlkey,HashMap<String,Object> params).getOne()

HashMap<String,String> getRows(String sqlkey,HashMap<String,Object> params)
HashMap<String,String> sql(String sqlkey,HashMap<String,Object> params).getRows()
String getRowsJson(String sqlkey,HashMap<String,Object> params)
String sql(String sqlkey,HashMap<String,Object> params).getRowsJson()
B getRows2b(String sqlkey,HashMap<String,Object> params)
B sql(String sqlkey,HashMap<String,Object> params).getRows2b()
T getRows(String sqlkey,HashMap<String,Object> params,Cl ass<T> t)
T sql(String sqlkey,HashMap<String,Object> params).getRows(Cl ass<T> t)

HashMap<String,Object> getRowsObj(String sqlkey,HashMap<String,Object> params)
HashMap<String,Object> sql(String sqlkey,HashMap<String,Object> params).getRowsObj()

ArrayList<String> getCols(String sqlkey,HashMap<String,Object> params)
ArrayList<String> sql(String sqlkey,HashMap<String,Object> params).getCols()
String getColsJson(String sqlkey,HashMap<String,Object> params)
String sql(String sqlkey,HashMap<String,Object> params).getColsJson()
ArrayList<B> getCols2b(String sqlkey,HashMap<String,Object> params)
ArrayList<B> sql(String sqlkey,HashMap<String,Object> params).getCols2b()
ArrayList<T> getCols(String sqlkey,HashMap<String,Object> params,Class<T> t)
ArrayList<T> sql(String sqlkey,HashMap<String,Object> params,Class<T> t).getCols()

String toSql(String sqlkey,HashMap<String,Object> params)
String sql(String sqlkey,HashMap<String,Object> params).toSql()

举例：
user.m文件内容
insertuser=insert into sc_user (username,password,sex) values('{$username}','sdf',2)
getusers=select * from sc_user where id<{$id}

控制器：
UserM um=new UserM();
    HashMap<String,Object> params=new HashMap<String,Object>();
    params.put("id",5);
    echo(um.select("getusers",params));

输出结果：

另类查询

DbResults select2c(String sqlkey,HashMap<String,Object> params)
DbResults sql(String sqlkey,HashMap<String,Object> params).select2()
DbResults preSelect2(String sqlkey,Object ...params)
DbResults sql(String sqlkey,Object ...params).preSelect2()

新增

int insert(String sqlkey,HashMap<String,Object> params)
int sql(String sqlkey,HashMap<String,Object> params).insert()

int query(String sqlkey,HashMap<String,Object> params)

更新

int sql(String sqlkey,HashMap<String,Object> params).update()
int query(String sqlkey,HashMap<String,Object> params)

删除

int sql(String sqlkey,HashMap<String,Object> params).delete()
int query(String sqlkey,HashMap<String,Object> params)

预处理

参数：Object ...params,可以是HashMap<Integer,Object> params
1、查询
ArrayList<HashMap> preSelect(String sqlkey,Object ...params)
ArrayList<HashMap> sql(String sqlkey).prepareSelect(Object ...params)
String preSelectJson(String sqlkey,Object ...params)
String sql(String sqlkey).prepareSelectJson(Object ...params)
ArrayList<B> preSelect2b(String sqlkey,Object ...params)
ArrayList<B> sql(String sqlkey).prepareSelect2b(Object ...params)
ArrayList<T> preSelect(String sqlkey,Class<T> t,Object ...params)
ArrayList<T> sql(String sqlkey).prepareSelect(Class<T> t,Object ...params)

String preOne(String sqlkey,Object ...params)
String sql(String sqlkey).prepareOne(Object ...params)

HashMap<String,String> preRows(String sqlkey,Object ...params)
HashMap<String,String> sql(String sqlkey).prepareRows(Object ...params)
String preRowsJson(String sqlkey,Object ...params)
String sql(String sqlkey).prepareRowsJson(Object ...params)
B preRows2b(String sqlkey,Object ...params)
B sql(String sqlkey).prepareRows2b(Object ...params)
T preRows(String sqlkey,Class<T> t,Object ...params)
T sql(String sqlkey).prepareRows(Class<T> t,Object ...params)

HashMap<String,Object> preRowsObj(String sqlkey,Object ...params)
HashMap<String,Object> sql(String sqlkey).prepareRowsObj(Object ...params)

ArrayList<String> preCols(String sqlkey,Object ...params)
ArrayList<String> sql(String sqlkey).prepareCols(Object ...params)
String preColsJson(String sqlkey,Object ...params)
String sql(String sqlkey).prepareColsJson(Object ...params)
ArrayList<B> preCols2b(String sqlkey,Object ...params)
ArrayList<B> sql(String sqlkey).prepareCols2b(Object ...params)
ArrayList<T> preCols(String sqlkey,Class<T> t,Object ...params)
ArrayList<T> sql(String sqlkey).prepareCols(Class<T> t,Object ...params)

2、插入
int preQuery(String sqlkey,Object ...params)
int sql(String sqlkey).prepareInsert(Object ...params)

3、更新
int preQuery(String sqlkey,Object ...params)
int sql(String sqlkey).prepareUpdate(Object ...params)

4、删除
int preQuery(String sqlkey,Object ...params)
int sql(String sqlkey).prepareDelete(Object ...params)

5、批量处理
第1步：void sql(String sqlkey).prepares()；//预处理准备
第2步（以下其一操作，重复多次情况用）：预处理执行
ArrayList<HashMap> preparesSelect(HashMap<Integer,Object> params)
String preparesSelectJson(HashMap<Integer,Object> params)
ArrayList<T> preparesSelect(HashMap<Integer,Object> params,Class<T> t)
String preparesOne(HashMap<Integer,Object> params)
HashMap<String,String> perparesRows(HashMap<Integer,Object> params)
String perparesRowsJson(HashMap<Integer,Object> params)
T perparesRows(HashMap<Integer,Object> params,Class<T> t)
ArrayList<String> preparesCols(HashMap<Integer,Object> params)
String preparesColsJson(HashMap<Integer,Object> params)
ArrayList<T> preparesCols(HashMap<Integer,Object> params,Class<T> t)
int preparesQuery(HashMap<Integer,Object> params)
第3步：
void preparesClose()；//关闭所有资源（必须）

批量处理

通用：
int[] preBatchQuery(String sqlkey,ArrayList<HashMap<Integer,Object>> params)
int[] sql(String sqlkey).preBatchQuery(ArrayList<HashMap<Integer,Object>> params)

一、批量新增
int[] sql(String sqlkey).prepareBatchInsert(ArrayList<HashMap<Integer,Object>> params)
int[] sql(String sqlkey).prepareBatchReplace(ArrayList<HashMap<Integer,Object>> params)

二、批量更新
int[] sql(String sqlkey).prepareBatchUpdate(ArrayList<HashMap<Integer,Object>> params)

三、批量删除
int[] sql(String sqlkey).prepareBatchDrop(ArrayList<HashMap<Integer,Object>> params)

事务处理

操作步骤（严格按照步骤,1、2，3、5，一步不能少）：

1、启动事务：
boolean transStart()
boolean transStart(String ISOLATION_LEVEL)//指定SESSION事务隔离级别，参数为：READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ、SERIALIZABLE
boolean transStart(Model ...models)//多个模型参与事务执行
boolean transStart(String ISOLATION_LEVEL,Model ...models)//指定SESSION事务隔离级别及多个模型参与事务执行

2、执行事务：
int transQuery(String sqlkey,HashMap<String,Object> params)
int transInsert(String sqlkey,HashMap<String,Object> params)
int transReplace(String sqlkey,HashMap<String,Object> params)
int transPreQuery(String sqlkey,HashMap<Integer,Object> params)
int sql(String sqlkey,HashMap<String,Object> params).transInsert()
int sql(String sqlkey,HashMap<String,Object> params).transReplace()
int sql(String sqlkey,HashMap<String,Object> params).transDrop()
int sql(String sqlkey,HashMap<String,Object> params).transUpdate()
int sql(String sqlkey).transPrepareInsert(HashMap<Integer,Object> params)
int[] sql(String sqlkey).transPrepareBatchInsert(ArrayList<HashMap<Integer,Object>> params)
int sql(String sqlkey).transPrepareReplace(HashMap<Integer,Object> params)
int[] sql(String sqlkey).transPrepareBatchReplace(ArrayList<HashMap<Integer,Object>> params)
int sql(String sqlkey).transPrepareUpdate(HashMap<Integer,Object> params)
int[] sql(String sqlkey).transPrepareBatchUpdate(ArrayList<HashMap<Integer,Object>> params)
int sql(String sqlkey).transPrepareDrop(HashMap<Integer,Object> params)
int[] sql(String sqlkey).transPrepareBatchDrop(ArrayList<HashMap<Integer,Object>> params)

3、提交事务
transCommit()

4、回滚事务（如果有异常,此步才需要）
transRollback()

5、结束事务
transEnd()
MyBatis

介绍

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
更多内容请前往MyBatis官方网站查看学习：http://www.mybatis.org

配置

麻烦是麻烦些，不过可以实现SQL与模型分离
mybatis-3.4.6.jar 放在站点WEB-INF/lib目录下
配置均放在WEB-INF/classes目录下
1、mysql.properties//数据源配置，这个可根据不同数据库进行设置
#######自定义配置
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/sc_test?characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
jdbc.username=root
jdbc.password=123456

2、mybatis.cfg.xml //mybatis配置文件格式必须一致
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

   
   <properties resource="mysql.properties"></properties>
   <typeAliases >
       
       
       <package name="test.z.mybatis.beans"/>
    </typeAliases>

    
      <environments default="cybatis">
         <environment id="cybatis">
             
             <transactionManager type="JDBC" />

             
             
             
             
             <dataSource type="POOLED">
                 <property name="driver" value="${jdbc.driver}" />
                 <property name="url" value="${jdbc.url}" />
                 <property name="username" value="${jdbc.username}" />
                 <property name="password" value="${jdbc.password}" />
             </dataSource>
         </environment>
     </environments>

      <mappers>
           
           <mapper resource="test/z/mybatis/mapper/TestMapper.xml"/>
           
         </mappers>

</configuration>

3、mapper配置，根据mybatis.cfg.xml中mappers节点的节点指定目录
这只是其中一个案例
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test.z.mybatis.mapper.TestMapper">

     <resultMap id="userMap" type="TestBean">
          <id property="id" column="id" javaType="java.lang.Integer"></id>
          <result property="username" column="username" javaType="java.lang.String"></result>
          <result property="password" column="password" javaType="java.lang.String"></result>
          <result property="sex" column="sex" javaType="java.lang.Integer"></result>
     </resultMap>





     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
         insert into sc_user (username,password,sex) values (#{username},#{password},#{sex})
     </insert>

     <update id="updateUser" >
       update sc_user set username=#{username},password=#{password},sex=#{sex} where id=#{id}
     </update>

     <delete id="deleteUser" parameterType="int">
      delete from sc_user where id=#{id}
     </delete>

     <select id="selectUserById" parameterType="int" resultMap="userMap">
      select * from sc_user where id=#{id}
     </select>

     <select id="selectAllUser" resultMap="userMap">
      select * from sc_user
     </select>

</mapper>

开发

1、编写实体Bean
package test.z.mybatis.beans;
import java.io.Serializable;
public class TestBean implements Serializable{
    private Integer id;
    private String username;
    private String password;
    private Integer sex;
    public TestBean() {
      super();
     }
public TestBean(String username,String password,int sex) {
      this.username=username;
      this.password=password;
      this.sex=sex;
     }
}

并在mybatis.cfg.xml中加入相关配置
   <typeAliases >
       
       
       <package name="test.z.mybatis.beans"/>
    </typeAliases>

2、编写Mapper
package test.z.mybatis.mapper;
import test.z.mybatis.beans.TestBean;
public interface TestMapper {
public int insertUser(TestBean tb) throws Exception;
}

并在mybatis.cfg.xml中加入相关配置
         <mappers>
           
           <mapper resource="test/z/mybatis/mapper/TestMapper.xml"/>
           
         </mappers>

3、编写Mapper配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test.z.mybatis.mapper.TestMapper">

     <resultMap id="userMap" type="TestBean">
          <id property="id" column="id" javaType="java.lang.Integer"></id>
          <result property="username" column="username" javaType="java.lang.String"></result>
          <result property="password" column="password" javaType="java.lang.String"></result>
          <result property="sex" column="sex" javaType="java.lang.Integer"></result>
     </resultMap>





     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
         insert into sc_user (username,password,sex) values (#{username},#{password},#{sex})
     </insert>

     <update id="updateUser" >
       update sc_user set username=#{username},password=#{password},sex=#{account} where id=#{id}
     </update>

     <delete id="deleteUser" parameterType="int">
      delete from sc_user where id=#{id}
     </delete>

     <select id="selectUserById" parameterType="int" resultMap="userMap">
      select * from sc_user where id=#{id}
     </select>

     <select id="selectAllUser" resultMap="userMap">
      select * from sc_user
     </select>

</mapper>

4、编写Model ,model 必须继承于BModel
package test.z.model;
import org.jkas.core.BModel;
public class TestBM extends BModel{
}

5、编写控制器
package test.z.app;
import test.z.mybatis.mapper.TestMapper;
import test.z.mybatis.beans.TestBean;
import test.z.model.TestBM;
public class Mbts extends FrontBase
{ public void index()
   { TestBM tb=new TestBM();
      TestMapper tm=tb.getMapper(TestMapper.class);
      TestBean test = new TestBean("周胡顺", "20181024", 1);
    try
    {
      tm.insertUser(test);
      tb.commit();
    }
    catch (Exception e)
    { tb.rollback();
       echo(e.toString());
    }
    finally
     {tb.close();//必须调用关闭连接
     }
    echo("ok");
}
}

使用结束必须调用.close()关闭会话，否则会导致连接没有关闭问题！
执行结果：
视图

视图操作

视图支持Beetl 、Thymeleaf、Freemarker、Velocity四种模板引擎，默认使用Beetl模板引擎，如果需要使用其它模板引擎，请框架配置文件中把视图引擎模板配置成相应模板引擎
[VIEW]
#beetl,thymeleaf,freemarker,velocity
view_engine=beetl

获取与设置：
String viewPath()//获取视图路径
void viewPath(String viewPath)//设置视图路径
String viewTheme()//获取主题路径
void viewTheme(String viewTheme)//设置主题路径
void viewInit()//初始化视图
void viewInit(String view_path,String view_theme)//带参数初始化视图
一、变量赋值
void assign(String k,Object v)

二，渲染模板
(使用Beetl引擎时)当调用模板渲染时出现空指针时检查classes目录下的beetl.properties文件是否存在或是最新版本。
void disp lay()//默认渲染控制器APP下面ACTION名称的模板
void display(String tpl)//tpl路径是以主题路径为基准(在开启模块功能情况下，还要加上模块路径)，渲染指定路径模板
String fetch()//获取渲染后控制器APP下面ACTION名称的模板内容
String fetch(String tpl)//获取指定tpl路径模板内容，路径是以站点根目录为基准

三、渲染字符串
String fetch_str(String str)

四、js操作
首要js引入jkas.js
js url格式化：
jkas.url(app/act,params);
js 价格格式化：
jkas.price(price,symbol)；//symbol可以不输入，默认为系统配置的货币符号，结果：￥5.00

Beetl

默认引擎
[VIEW]
view_engine=beetl

模板语法（仅支持Beetl模板引擎）
timeFormat//日期格式化如：${strdate,timeFormat="yyyy-MM-dd"}
byteFormat//文件大小格式化，如：${size,byteFormat="M"} K/M/G/T/P为参数，不传参数将自动计算适合单位
ipFormat//对整数IP进行格式化处理，如：${-1062731510,ipFormat}，则输出 192.168.1.10
timeScale//对整数进行时分秒转换处理，如${96,timeScale=''}，则输出 1分36秒 timeScale的值可以是空，也可以是d/h/m/s/n/cn/en[|en/cn/n]之一.d表是按天输出，h表示按小时输出，m表示按分钟输出，s表示按秒输出，n表示不输出单位,cn中文单位，en英文单位，如：${96,timeScale='en'}，则输出 1m36s ；如：${96,timeScale='m|en'}，则输出1.6m
strCut//字符串截取如：${str,strCut="5"}
price//四舍五入保留两个小数据如${price,price}默认为系统配置好的货币符号开头,保留2位小数，可指定price的值，price值可指定开头符号和保留小数位数，同时指定用逗号分隔，如：${price,price="$,3"},结果：$5.000,如果只有一个参数时，参数为字符则为货币符号，如${price,price='$'},结果：$5.00，参数为数字则是保留小数位数，如${price,price='3'},结果：￥5.000
nl2br//实现把回车换行替换成<br/>，如${"aaa bbb",nlbr},则输出aaa<br/>bbb
mask//把指定位置的字符替换成****,默认把中间替换成****，当指定位置时，则替换指定位置的内容为****
url / url(url,params)//格式化url,
如：<% url("test/url","a=b&c=d&e=f");%> 输出test/url/a/b/c/d/e/f.do
${'abc/def',url} 输出/abc/def.do
${'abc/def',url="a=b&c=d"} 输出 /abc/def/a/b/c/d.do
${'abc/def/page/'+pageinfo.page,url="a=b&c=d"} 输出 /abc/def/page/1/a/b/c/d.do
urlencode//url编码，如${url,urlencode}默认,${url,urlencode='escape"}以escape方式编码
format / fmt(String str,Object param1,Object param2,...)//格式化输出
如：${fmt('abcd%s,efg%d','yes',5)}
${'abcd%s,efg%d',format='yes,5'}//这种方式缺点是后面格式参数不能使用变量

html//html编码，参数有 en|unen|es|unes|text|txt|entext|entxt 没有参数默认为en,en对html符号进行转义，unen对html实体反转义，es对字符串进行escape编码，unes对字符串进行unescape解码，text|txt去除html符号 entext|entxt去除html编码后，对特殊符号如引号等进行转义

请阅读官方文档：http://ibeetl.com/guide/#beetl

Thymeleaf

1、请把修改框架配置文件模板配置：
[VIEW]
view_engine=thymeleaf

2、把Thymeleaf的依赖放到WEB-INF/lib目录下

详细模板语法请参考官方文档：https://www.thymeleaf.org/

Freemarker

1、请把修改框架配置文件模板配置：
[VIEW]
view_engine=freemarker

2、把Freemarker的依赖放到WEB-INF/lib目录下

详细模板语法请参考官方文档：https://freemarker.apache.org/

Velocity

1、请把修改框架配置文件模板配置：
[VIEW]
view_engine=velocity

2、把Velocity的依赖放到WEB-INF/lib目录下

详细模板语法请参考官方文档：https://velocity.apache.org/
缓存

Jkas 缓存读写

注：缓存操作前，请先配置好缓存并启用缓存

一、缓存读取
T cac he(String key) //T 代表自定义返回类型，类型错误将返回null，返回类型必须是对象，不能是8种基本类型（切记），如果使用，要自行处理异常。
String cacheStr(String key)
int cache2int(String key)
long cache2long(String key)
float cache2float(String key)
double cache2double(String key)

二、缓存写入
void cache(String key,Object value)
void cache(String key,Object value,int expired)

三、缓存删除
void cache(String key,null)
void cachedel(String key);

四、缓存清空
void cache(0)
void cacheclean();
void cacheclear();
分布式

ZooKeeper

1、在配置文件里面设置好ZooKeeper参数
[ZOOKEEPER]
#是否开启zookeeper，开启服务将在框架启动时自动连接zookeeper节点，并完成默认节点文件加载创建
zk_enable=1
#zookeeper集群地址，多个用逗号隔开
zk_hosts=127.0.0.1:2181
#权限控制模式，没有就不用设置
#zk_scheme=
#具体权限信息
#zk_auth=
#zookeeper连接超时
zk_timeout=3000
#监听回调类设置，回调类必须继承JkasZkWatcher
zk_watcherclass=test.z.zookeeper.Test

2、默认加载创建节点文件
文件位置位于data/zktab文件，启动或文件被修改将重新加载创建节点
文件结构：节点:节点值|是否监听|节点类型|访问权限1|访问权限2|访问权限n...
#权限控制模式分为:world、auth、digest、ip和super
#acl r:read w:write c:create d:delete a:admin
#creatMode 0:临时 1:临时顺序 2:永久 3:永久顺序
#每行一个节点，如下：
/test:v|0|0|world:anyone:cwrad|ip:192.168.1.5:cw|ip:192.168.1.8:rw
/tes2:c|1

3、常用方法
protected String zkCreate(String key,String value)
protected String zkCreate(String key,String value,boolean watcher)//watcher是否监听，监听节点的添加、修改、删除，通过监听事件通知,下同
protected String zkCreate(String key,String value,int createmode)//createmode为节点类型 0:临时 1:临时顺序 2:永久 3:永久顺序
protected String zkCreate(String key,String value,int createmode,boolean watcher)//createmode为节点类型 0:临时 1:临时顺序 2:永久 3:永久顺序
protected String zkCreate(String key,String value,String acls,int createmode)//acls 为访问权限，结构如：world:anyone:cwrad|ip:192.168.1.5:cw|ip:192.168.1.8:rw
protected String zkCreate(String key,String value,String acls,int createmode,boolean watcher)//acls 为访问权限，结构如：world:anyone:cwrad|ip:192.168.1.5:cw|ip:192.168.1.8:rw
protected byte[] zkGetData(String key)
protected String zkGet(String key)
protected List<String> zkGetChildren(String key)
protected boolean zkSetData(String key,String value)
protected boolean zkDelete(String key)
protected boolean zkExists(String key)
protected boolean zkWatcher(String key)//监听节点的添加、修改、删除，通过监听事件通知
protected String zkGetState()

4、关于回调监听类
回调类必须继承于JkasZkWatcher，并覆盖相应方法，如下：
package test.z.zookeeper;
import org.jkas.JkasZkWatcher;
public class Text extends JkasZkWatcher{
public void zkconnected(){};//连接时调用
public void zkdisconnected(){};//断开连接时调用
public void zkcreated(String node,byte[] value){};//创建节点时调用
public void zkupdated(String node,byte[] value){};//修改节点时调用
public void zkdeleted(String node){};//删除节点时调用
}

     5、分布式锁
    import org.jkas.core.ZkLock;//导入ZkLock
   ZkLock lock=new ZkLock();//实例化 ZkLock
   boolean lock.tryLock(String key)//获取分布式锁,参数key为节点标志,返回true则成功获取，默认30秒没获得锁将超时返回false
   boolean lock.tryLock(String key,int timeout)//获取分布式锁,参数key为节点标志,返回true则成功获取，timeout为超过秒数没获得锁将超时返回false，timeout为0则一直等待直到获得锁
   void lock.unLock(String key);//释放分布式锁
   如：
   ZkLock lock=new ZkLock();
   try{
       if(lock.tryLock("/tttt"))
      {
          echo("获得锁");
       }
     }catch(Exception e){
     }
     finally{
      lock.unLock("/tttt");//无论是否获得锁，一定要释放锁
    }
国际化多语言

Jkas多语言实现

语言需要初始化方可用：
初始化方法：
localeInit();

语言统一放在loc ale目录下面，按控制器小写名称进行命名，在开启模块功能情况下，还要加上模块路径

系统会根据Cookie的locale值自动加载不同语言

语言文件是键值对方式，样例如下：
common.l //视图或程序全局通用
common.j //json全局通用
locale/zh_CN/login.l //视图语言
locale/zh_CN/login.j //json语言，专供js调用，调用方法 JL.null_username

null_username=用户名不能为空
null_password=密码不能为空
wrong_auth=用户名密码不正确
wrong_capacha=验证码不正确

语言文件读取用 String L(String lanname)

如：
程序调用：String notice=L("null_username");//notice的值为用户名不能为空

视图调用：${L.null_username}

JS调用先引入：<script type="text/javascript" src="[/模块名称]/app名称/jslang.jl"></script>
JS调用： JL.null_username
定时任务

Jkas定时任务操作

1、在配置文件里面设置好定时任务参数
[CRON]
；定时任务的包名
cron_package=test.z.cron
；是否开启定时任务
cron_enable=1
；是否开启定时任务日志输出，定时日志目录为temp/logs/jkas_cron_年-月.log
cron_log_enable=1

2、编写定时任务类和方法
类必须导入org.jkas.Cron包并继承于Cron
类方法必须为public方法，方法返回类型不限定，可为void,如开启日志，返回值会被转换成字符串写入定时任务日志
系统保留方法：start，init,release,destroy,如果有这些方法，系统将直接转到index方法
如：
package test.z.cron;
import org.jkas.core.Cron;
public class Test2 extends Cron
{ public boolean init()//覆盖父类方法，返回false将不再往下执行action
     {//初始操作
       return true;
      }
    public String paynotify()
    { String str=randStr();
       log("info",str);
       return str;
   }

      public void release()//覆盖父类方法
        {//可在这释放全局变量操作
        }

    }

3、配置定时任务表
任务表位于data目录crontab文件,任务优先级：按顺序从第1行往后执行
如：
0/10 * * * * ?|Test2 paynotify|test cron //每10秒执行一次类Text2的paynotify方法
配置方法见附件定时任务规则

4、定时任务管理
ArrayList<HashMap<String,String>> cronList()//读取任务列表 ,HashMap结构：expression,app,act,description
boolean cronAdd(String expression,String app,String act,String description)//新增定时任务
boolean cronEdit(int index,String expression,String app,String act,String description)//编辑定时任务，index为行号，从1开始计
boolean cronDel(int index)//删除定时任务，index为行号，从1开始计
boolean cronClear()//清空定时任务，整个crontab文件删除
String cronErrors()//返回添加编辑遇到的异常
队列任务

Jkas队列任务操作

按照一定的顺序异步执行任务，避免系统并发卡住

1、设置好配置文件
[QUEUE]
；是否启用队列
queue_enable=1
；队列执行自定义类
queue_class=test.z.queue.MyQueue
；队列执行间隔时间，单位微秒，1秒=1000微秒
queue_interval=5000

2、编写队列执行类并覆盖doQueue方法
类必须导入org.jkas.core.JkasQueue包并继承于JkasQueue
覆盖public void doQueue(int type,String title,Object data)方法
参数说明：
type:自定义来判断该队列该如何执行，如发邮件，发短信等
title:队列名称，可按需使用
data:队列数据，可按需使用，可以是任何对象，使用前后进行相应转换

如：
package test.z.queue;
import org.jkas.core.JkasQueue;
public class MyQueue extends JkasQueue
{
public void doQueue(int type,String title,Object data)
{System.out.println(title+data);//根据type,data类型做你想做的事
}
}

3、队列方法
boolean queue(int type,String title,Object data);//加入队列，等待执行
消息队列

MQTT

1、在配置文件里面设置好MQTT参数
[MQTT]
#是否开启MQTT服务
mq_enable=0
#MQTT服务器地址
mq_host=localhost:61613
#MQTT 客户端唯一ID
mq_id=jkas1121
#MQTT登录用户名
mq_user=admin
#MQTT登录密码
mq_pass=123456
#是否开启断开自动重连
mq_autoreconnect=1
#是否清除session
mq_cleansession=1
#连接超时
mq_timeout=10
#保持连接心跳时间
mq_keepalive=20
#默认订阅主题,中括号内容可以省略，格式为：主题名称1[:qos],主题名称2[:qos]
mq_subtopics=test2:2,test3
#收到收到消息回调类，必须继承于JkasMQBack
mq_callbackclass=test.z.mqtt.Test
#是否启用安全通信
mq_ssl=0
#CA根证书绝对路径
mq_cafile=
#公钥证书绝对路径
mq_crtfile=
#私钥证书绝对路径
mq_keyfile=
#证书密码
mq_keypass=

2、常用方法
String mqGetId()//获取客户端ID
boolean mqSendMsg(String topic,String msg)//向指定主题发送消息
boolean mqSendMsg(String topic,String msg,int qos)//向指定主题发送消息,qos 0:至少0次收到，1:至少1次收到 2:刚好1次收到
boolean mqSubTopics(String[] topics,int[] qos)//批量订阅主题，qos 0:至少0次收到，1:至少1次收到 2:刚好1次收到
boolean mqSubTopics(String[] topics)//批量订阅主题，qos默认为0
boolean mqSubTopic(String topic,int qos)//单条订单主题,指定qos
boolean mqSubTopic(String topic)//单条订阅主题，qos默认为0
boolean mqUnSubTopics(String[] topics)//批量取消订阅主题
boolean mqUnSubTopic(String topic)//单条取消订阅主题

3、关于回调类
该类必须继承于JkasMQBack，并覆盖相应方法，如下示例：
package test.z.mqtt;
import org.jkas.core.JkasMQBack;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
public class Test extends JkasMQBack
{
public void connectionLost(Throwable arg) {//连接断开
}
public void deliveryComplete(IMqttDeliveryToken token) {//发布完成
}
public void messageArrived(String topic, MqttMessage msg) throws Exception {//收到消息
}
}

ROCKETMQ

1、在配置文件里面设置好ROCKETMQ参数
[ROCKETMQ]
#是否开启服务功能
rq_enable=1
#ROCKETMQ服务地址，可集群，多个用分号隔开
rq_nameserver=localhost:9876
#客户端ID
rq_groupid=jkas1122
#验证用户名
rq_user=
#验证密码
rq_pass=
#重试底数
rq_retrytimes=4
#开启重试
rq_retryanother=1
#默认订阅主题
rq_subtopics=test2,test3
#收到消息回调类，必须继承于JkasRQBack
rq_callbackclass=test.z.rocketmq.Test

2、常用方法
protected String rqSendMsg(String topic,String msg)//发送消息到指定主题
protected String rqSendMsg(String topic,String tag,String msg)//发送消息到指定主题，设定tag
protected String rqSendMsg(String topic,String tag,String key,String msg)//发送消息到指定主题，设定tag和key
protected boolean rqSubTopic(String topic)//订阅主题
protected boolean rqSubTopic(String topic,String subExpression)//订阅主题，并指定subExpression

    3、关于收到消息回调类
    该类必须继承于JkasMQBack，并覆盖相应方法，如下示例：
package test.z.rocketmq;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.jkas.core.JkasRQBack;
   public class Test extends JkasRQBack
{
     public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,ConsumeConcurrentlyContext context) {//收到消息
       return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
     }

}
事件监听

jkas 事件监听

1、配置
[LISTENER]
；是否开启监听器
listener_enable=1
;监听器指定调用类设置，该类必须继承Listener
listener_class=test.z.listener.Test

2、监听类及方法编写
监听类必须继承于Listener,重写以下监听方法分别监听不同事件
public void sessionCreate(HttpSessionEvent hse){};//session创建，用户首次访问
public void sessionAdd(HttpSessionBindingEvent hsbe){};//session添加
public void sessionUpdate(HttpSessionBindingEvent hsbe){};//session更新
public void sessionRemove(HttpSessionBindingEvent hsbe){};//session删除
public void sessionDestroy(HttpSessionEvent hse){};//session销毁
public void requestInit(ServletRequestEvent sre){}; //request初始
public void requestAdd(ServletRequestAttributeEvent srae){};//request添加
public void requestUpdate(ServletRequestAttributeEvent srae){};//request更新
public void requestRemove(ServletRequestAttributeEvent srae){};//request删除
public void requestDestroy(ServletRequestEvent sre){};//request销毁

public void applicationAdd(ServletContextAttributeEvent scae){};//application变量添加
public void applicationUpdate(ServletContextAttributeEvent scae){};//application变量更新
public void applicationRemove(ServletContextAttributeEvent scae){};//application删除

public void JkasInit(Config conf)//框架初始化，仅启动时执行，不受配置监听开关影响
public void JkasDestroy(Config conf)//框架销毁时执行，不受配置监听开关影响

public void zkconnected(){}; //zookeeper连接
public void zkdisconnected(){};//zookeeper断开连接
public void zkcreated(String node,byte[] value){};//zookeeper创建节点
public void zkupdated(String node,byte[] value){};//zookeeper修改节点
public void zkdeleted(String node){};//zookeeper删除节点

案例：监听session添加事件及session删除事件

package test.z.listener;
import org.jkas.core.Listener;
import javax.servlet.http.HttpSessionBindingEvent;
public class Test extends Listener
{ public void sessionAdd(HttpSessionBindingEvent hsbe)
{log("info","session add");
}
public void sessionRemove(HttpSessionBindingEvent hsbe)
{log("info","session remove");
}
}

jkas 文件监听

1、配置
[FILELISTENER]
；是否开启监听器
fllistener_enable=1
;监听器指定调用类设置，该类必须继承JkasFileListener
flistener_package=test.z.filelistener

2、编写文件类和方法
类必须导入org.jkas.JkasFileListener包并继承于JkasFileListener
类方法必须为public方法，方法返回类型不限定，可为void,如开启日志，返回值会被转换成字符串写入定时任务日志
系统保留方法：start，init,release,destroy,如果有这些方法，系统将直接转到index方法

String getPath()//获取文件路径
String getDescription()//获取文件描述

如：
package test.z.filelistener;
import org.jkas.core.JkasFileListener;
public class Test2 extends JkasFileListener
{ public boolean init()//覆盖父类方法，返回false将不再往下执行action
     {//初始操作
       return true;
      }
    public String filenotify()
    { System.out.println(getPath()+getDescription());
      return time();
    }

      public void release()//覆盖父类方法
        {//可在这释放全局变量操作
        }

    }

3、配置监听文件列表
任务表位于data目录filestab文件,任务优先级：按顺序从第1行往后执行
如：
/www/kk.txt|Test2 filenotify|test cron //监听到文件/www/kk.txt发生改变，执行一次类Text2的filenotify方法
过滤器

jkas 访问过滤

1、配置
[FILTER]
；是否开启过滤器
filter_enable=1
;过滤指定调用类设置，该类必须继承Filters
filter_class=test.z.filter.Test
；系统过滤字符设置，多个用|分开
filter_str=敏感词1|敏感词2|...|敏感词n
2、编写过滤器类及方法

类必须继承于Filters,该类必须指定doFilter方法来进行过滤操作
返回空字符串，不拦截，返回非空字符串，进行拦截，不往下执行！
如:
package test.z.filter;
import org.jkas.core.Filters;
import javax.servlet.ServletRequest;
public class Test extends Filters
{ public String doFilter(ServletRequest req，String paramstrs)//paramstrs为请求的参数、路径转换成的字符串
   { //在这里做你想做的
      return "filter reason";
   }
}
URL别名

jkas url别名

该功能实现控制器和Action可以自定义别名

1、配置
[SERVER]
;url 别名是否开启,1为开启，开启后需要在/data/alias文件配置好别名设置
url_alias=1

2、设置好/data/alias文件内容
控制器名首字母必须大写,控制器与Action之间用点（"."）号分隔
如下所示：
[K]
K=Vtest
K.index=Test.index
K.info=Goods.detail

配置好后，访问规则：
http://www.jkas.org/k/3.htm ----> http://www.jkas.org/test/3.htm //别名规则 K.index
http://www.jkas.org/k/param1/3.htm ----> http://www.jkas.org/vtest/param1/3.htm //别名规则 K=Vtest
http://www.jkas.org/k/info/3.htm ----> http://www.jkas.org/goods/detail/3.htm //别名规则 K.info=Goods.detail
高级工具

高级工具介绍

高级工具类，实现编码解码、加密解密、有效验证、验证码、PDF读取等多种便捷操作。
如果要自已写扩展，并且要用到框架已有方法，请继承Utils (org.jkas.core.Utils)

加密与解密

1、MD5
String md5(String str)
String md5(byte[] str)//字节流
Sring md5f(String filepath)//计算文件的MD5值

2、SHA
String sha(String str);//默认128位
String sha(byte[] str);//字节流，默认128位
String sha1(String str);//128位
String sha1(byte[] str);//字节流，128位
String sha2(String str);//256位
String sha2(byte[] str);//字节流，256位
String sha3(String str);//384位
String sha3(byte[] str);//字节流，384位
String sha5(String str);//512位
String sha5(byte[] str);//字节流，512位
String sha(String str,int bit)//bit 为256 384 512
String sha(byte[] str,int bit)//bit 为256 384 512
String shaf(String filepath)//计算文件的SHA1值
String shaf(String filepath,int bit)//计算文件的SHA1 SHA256 SHA384 SHA512值 bit 为1 256 384 512

3、RSA
密钥生成：
HashMap<String,String> rsaGenerateKey()//privatekey，publickey 默认1024位
HashMap<String,String> rsaGenerateKey(int keysize)//privatekey，publickey，keysize值是512-65536之间，必须是64的倍数
/*
值得注意的是，如果选择密钥是1024bit长的，那么支持加密的明文长度字节最多只能是1024/8=128byte；

*/

密钥转换：
String rsaPrikey2pem(String prikey)//rsa私钥转换成pem格式
String rsaPubkey2pem(String pubkey)//rsa公钥转换成pem格式
String[] rsakey2pem(String prikey,String pubkey)//rsa密钥转换成pem格式，返回数组0的值是公钥，1的值是私钥

加密：
byte[] rsaEncode(String pubkey,String str)//pubkey为base64编码
byte[] rsaEncode(String pubkey,byte[] str)
byte[] rsaEncode(byte[] pubkey,byte[] str)

解密：
String rsaDecode(String prikey,String enstr) //prikey,enstr均为base64编码
String rsaDecode(String prikey,byte[] enstr)
String rsaDecode(byte[] prikey,byte[] enstr)
byte[] rsaDecodeBytes(String prikey,String enstr)
byte[] rsaDecodeBytes(String prikey,byte[] enstr)
byte[] rsaDecodeBytes(byte[] prikey,byte[] enstr)

签名与验签：
String RsaSignMd5(String src,String privateKeyEnc)// 签名方式：MD5withRSA src:签名字符串,privateKeyEnc:私钥
boolean RsaVerifyMd5(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String RsaSignSha1(String src,String privateKeyEnc)// 签名方式：SHA1withRSA src:签名字符串,privateKeyEnc:私钥
boolean RsaVerifySha1(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String RsaSignSha2(String src,String privateKeyEnc)// 签名方式：SHA256withRSA src:签名字符串,privateKeyEnc:私钥
boolean RsaVerifySha2(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String RsaSignSha3(String src,String privateKeyEnc)// 签名方式：SHA384withRSA src:签名字符串,privateKeyEnc:私钥
boolean RsaVerifySha3(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String RsaSignSha5(String src,String privateKeyEnc)// 签名方式：SHA512withRSA src:签名字符串,privateKeyEnc:私钥
boolean RsaVerifySha5(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

4、DES(注：此加密方式为本框架定制专用，不能通用)
说明：
* DES的密钥(key)长度是为8个字节,加密解密的速度是最快的
* DESede的密钥(key)长度是24个字节，即3DES
* AES的密钥(key)长度是16个字节
* BlowFish的密钥(key)长度是可变的(1<=key<=16),加密最快,强度最高

加密：
byte[] desEncode(String str,String key)//默认以DES方式加密
byte[] desEncode(String data,String key,String algorithm)//algorithm: 加密方式，值必须为 DES | DESede | Blowfish | AES 之一，下同
byte[] desEncodeBytes(byte[] data,String key)
byte[] desEncodeBytes(byte[] data,String key,String algorithm)
boolean desEncodeFile(String file,String desfile,String key)//file:需要加密的文件地址，desfile:加密后保存的文件地址
boolean desEncodeFile(String filepath,String desfile,String key,String algorithm)

解密：
String desDecode(byte[] data,String key)
String desDecode(byte[] data,String key,String algorithm)
byte[] desDecodeBytes(byte[] data,String key)
byte[] desDecodeBytes(byte[] data,String key,String algorithm)
byte[] desDecodeFile(String encfile,String key)
byte[] desDecodeFile(String filepath,String key,String algorithm)
String desDecodeFileStr(String encfile,String key)//encfile:已经加密过的文件地址
String desDecodeFileStr(String filepath,String key,String algorithm)

5、AES(128位，注：此加密方式为本框架定制专用，不能通用)
加密：
byte[] aesEncode(String str,String key)
byte[] aesEncodeBytes(byte[] data,String key)

解密：
String aesDecode(byte[] data,String key)
byte[] aesDecodeBytes(byte[] data,String key)

6、DSA
密钥生成：
HashMap<String,String> dsaGenerateKey()//privatekey为私钥，publickey为公钥,默认1024位
HashMap<String,String> dsaGenerateKey(int keysize)//privatekey为私钥，publickey为公钥,keysize值是512-65536之间，必须是64的倍数

密钥转换：
String dsaPrikey2pem(String prikey)//rsa私钥转换成pem格式
String dsaPubkey2pem(String pubkey)//rsa公钥转换成pem格式
String[] dsakey2pem(String prikey,String pubkey)//rsa密钥转换成pem格式，返回数组0的值是公钥，1的值是私钥

签名与验签：

String DsaSignSha1(String src,String privateKeyEnc)// 签名方式：SHA1withRSA src:签名字符串,privateKeyEnc:私钥注：密钥长度为1024
boolean DsaVerifySha1(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String DsaSignSha2(String src,String privateKeyEnc)// 签名方式：SHA256withRSA src:签名字符串,privateKeyEnc:私钥
boolean DsaVerifySha2(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String DsaSignSha3(String src,String privateKeyEnc)// 签名方式：SHA384withRSA src:签名字符串,privateKeyEnc:私钥
boolean DsaVerifySha3(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

String DsaSignSha5(String src,String privateKeyEnc)// 签名方式：SHA512withRSA src:签名字符串,privateKeyEnc:私钥
boolean DsaVerifySha5(String src, String result,String publicKeyEnc)//验签 src:签名原字符串，result:签名，publicKeyEnc：公钥

7、ECDSA 椭圆曲线数字签名算法
密钥生成：
HashMap<String,String> EcdsaGenerateKey()//privatekey为私钥，publickey为公钥，默认256
HashMap<String,String> EcdsaGenerateKey(int keysize)//privatekey为私钥，publickey为公钥,keysize值是112-571

签名与验签：
String EcdsaSign(String src,String privateKeyEnc)//src:签名字符串,privateKeyEnc:私钥 SHA1withECDSA
boolean EcdsaVerify(String src, String result,String publicKeyEnc)//src:签名原字符串，result:签名，publicKeyEnc：公钥 SHA1withECDSA

String EcdsaSign2(String src,String privateKeyEnc)//src:签名字符串,privateKeyEnc:私钥 SHA2withECDSA
boolean EcdsaVerify2(String src, String result,String publicKeyEnc)//src:签名原字符串，result:签名，publicKeyEnc：公钥 SHA2withECDSA

String EcdsaSign3(String src,String privateKeyEnc)//src:签名字符串,privateKeyEnc:私钥 SHA3withECDSA
boolean EcdsaVerify3(String src, String result,String publicKeyEnc)//src:签名原字符串，result:签名，publicKeyEnc：公钥 SHA3withECDSA

String EcdsaSign5(String src,String privateKeyEnc)//src:签名字符串,privateKeyEnc:私钥 SHA5withECDSA
boolean EcdsaVerify5(String src, String result,String publicKeyEnc)//src:签名原字符串，result:签名，publicKeyEnc：公钥 SHA5withECDSA

8、HMAC 哈希消息认证码
String hmacMd5Key()
String hmacMd5(String str,String key)

String hmacSha1Key()
String hmacSha1(String str,String key)

String hmacSha2Key()
String hmacSha2(String str,String key)

String hmacSha3Key()
String hmacSha3(String str,String key)

String hmacSha5Key()
String hmacSha5(String str,String key)

编码解码

1、Bas e64
String base64Encode(String str)//编码
String base64Encode(byte[] str)//字节流编码
String base64Decode(String str)//解码
String base64EncodeFile(String filepath)//对文件进行编码
byte[] base64ToBytes(String str)//解码成字节流
byte[] base64FileToBytes(String filepath)//解码base64文件成字节流

2、Base58
String base58Encode(String str)//编码
String base58Encode(byte[] str)//字节流编码
String base58EncodeFile(String filepath)//对文件进行编码
String base58Decode(String str)//解码
byte[] base58ToBytes(String str)//解码成字节流
byte[] base58FileToBytes(String filepath)//解码base58文件成字节流

3、JS ON[注意二者选其一，避免冲突]
JSONArray jsonArr(Object obj)//转成json数组，net.sf.json.JSONArray
JSONObject json(Object obj)//转成json对象，net.sf.json.JSONObject
JSONObject fastjson(String str)//com.alibaba.fastjson.JSONObject
JSONObject map2fastjson(HashMap<String,Object> data)//com.alibaba.fastjson.JSONArray
JSONArray fastjsonArr(String str)//com.alibaba.fastjson.JSONArray
JSONArray fastjsonArr(ArrayList<Object> data)//com.alibaba.fastjson.JSONArray
String jsonStr(Object obj)//对象或数组转成json字符串
String jsonObjStr(Object obj)//对象转json字符串
String jsonArrayStr(Object obj)//数组转json字符串
HashMap<String,Object> json2map(Object json)//json对象转为map格式
HashMap<String,Object> json2map(String jsonstr)//json字符串转为map格式
String map2json(HashMap<String,Object> data)

4、XML&Map
HashMap<String, String> xml2map(String strXML)//xml转map
String map2xml(HashMap<String, String> data)//map转xml

5、url编码
String urlencode(String str);//默认认框架编码
String urlencode(String str,String charset)
String urldecode(String str);//默认认框架编码
String urldecode(String str,String charset);
HashMap<String,String> url2map(String params);//把URL格式键值对转换成HashMap格式
String sorturl(String params);//把url的键值对按键名升序排序参数如：c=1&e=3&b=2 输出结果：b=2&c=1&e=3
String mapsorturl(HashMap<String,String> params);//键值对的参数按键名升序排序输出URL格式键值对
String mapobjsorturl(HashMap<String,Object> params);//键值对的参数按键名升序排序输出URL格式键值对

6、字符转16进制
String str2hex(String str)
String hex2str(String str)
String bytes2hex(byte[] str)

7、字符转Unicode
String str2unicode(String str)
String unicode2str(String unicode)

8、数字(10进制）转62进制
String numto62(int num)//整型转62进制
String numto62(long num)//长整型转62进制
long f62tonum(String str)//从62进制字符串转长整型（10进制）

9、数字(10进制）转2-62进制
String numconv(int num,int scale)//整型转2-62进制
String numconv(long num,int scale)//长整型转2-62进制
long convnum(String str,int scale)//从2-62进制字符串转长整型（10进制）

10、HashMap与实体Bean互转
T map2bean(HashMap<K, V> mp, Class<T> beanCls)//HashMap转JavaBean
HashMap<String, Object> bean2map(T bean, HashMap<String, Object> mp)//JavaBean转HashMap

11、HTML转码
String escape(String str)
String unescape(String enstr)
String htmlentities(String str)
String htmlunentities(String enstr)
String html2text(String htmlstr)//去除html标签，保留文本
String safeWithImageHtml(String htmlstr)//保留<img>并去除不安全的html标签，如<script>等，预防xss攻击
String safeHtml(String htmlstr))//去除不安全的html标签，如<script>等，预防xss攻击
String cleanHtml(String htmlstr))//去除所有的html标签

12、编码转换
String iconv(String str,String fromcharset,String tocharset)

13、IPv4转码
String int2ip(int ip)
int ip2int(String ip)

14、字母拼音
char firstLetter(String str)//获取字符串（中文拼音）首字母（大写），
String eachFirstLetter(String str)//获取每个字符拼音首字母，英文原样输出
String pinyin(String str)//获取中文字符完整拼音，英文原样输出
String fullSpell(String str)//获取中文字符完整拼音，英文原样输出

15、序列化
byte[] serialize(Object object)//序列化
Object unserialize(byte[] bytes) //反序列化

一维码生成与解码

1、编码
String barcode(String contents,String format,int width,int height,String savepath,String filename)//format:条码类型，ean_8,ean_13,code_39,code_128,codabar
BufferedImage barcode(String contents,String format,int width,int height)//format:条码类型，ean_8,ean_13,code_39,code_128,codabar
void barcodeOut(String contents,String format,int width,int height)//直接输出到浏览器，format:条码类型，ean_8,ean_13,code_39,code_128,codabar

条码知识：
Code39码（标准39码）、Codabar码（库德巴码)、EAN-13码（EAN-13国际商品条码）、EAN-8码（EAN-8国际商品条码）、Code128码（Code128码，包括EAN128码）

在EAN-13的编码体系中，前三位数字表示商品生产商的国家（并不是商品所属公司的国家），中国的编码是690~699，美国是（000~019、030~039、060~139），日本是（450~459、490~499）

2、解码
    String barDecode(String filename)

二维码生成与解码

1、编码
     /*参数说明
      String str : 需要编码字符
      int size : 二维码大小，像素单位
      int onColor : 前景色，整数颜色如 0xFF000000
      int offColor : 背景色，整数颜色如 0xFFFFFFFF
      String savepath : 二维保存地址
      String filename : 二维码保存名称
      String logopath : 二维码需要加logo的路径
      String text : 二维码下方的文本内容
      boolean round : 二维码是否为圆角
      boolean transparent : 二维码是否为透明背景
    */

    /*---保存为文件---*/
    String qrcode(String str,int size,int onColor,int offColor,String savepath,String filename)
    String qrcode(String str,int size,int onColor,int offColor,String savepath,String filename,String logopath,String text)
    String qrcode(String str,int size,int onColor,int offColor,String savepath,String filename,String logopath,String text,boolean round,boolean transparent)
    String qrcode(String str,int size,String savepath,String filename)
    String qrcode(String str,int size,String savepath,String filename,String logopath,String text)
    String qrcode(String str,int size,String savepath,String filename,String logopath,String text,boolean round,boolean transparent)

    String qrcodelogo(String str,int size,String savepath,String filename,String logopath)
    String qrcodelogo(String str,int size,String savepath,String filename,String logopath,String text)
    String qrcodelogo(String str,int size,String savepath,String filename,String logopath,String text,boolean round,boolean transparent)

    String qrcodetext(String str,int size,String savepath,String filename,String text)

    /*---输出base64字符串---*/
    String qrcode2base64(String str,int size)
    String qrcode2base64(String str,int size,int onColor,int offColor)
    String qrcodelogo2base64(String str,int size,int onColor,int offColor,String logopath)
    String qrcodelogo2base64(String str,int size,int onColor,int offColor,String logopath,String text)
    String qrcodelogo2base64(String str,int size,String logopath)

    String qrcodetext2base64(String str,int size,int onColor,int offColor,String text)
    String qrcodetext2base64(String str,int size,String logopath,String text)
    String qrcodetext2base64(String str,int size,String text)

    /*---输出图像数据---*/
    BufferedImage qrcode(String str,int size)
    BufferedImage qrcode(String str,int size,int onColor,int offColor)

    BufferedImage qrcodelogo(String str,int size,int onColor,int offColor,String logopath)
    BufferedImage qrcodelogo(String str,int size,int onColor,int offColor,String logopath,String text)
    BufferedImage qrcodelogo(String str,int size,int onColor,int offColor,String logopath,String text,boolean round,boolean transparent)
    BufferedImage qrcodelogo(String str,int size,String logopath)
    BufferedImage qrcodelogo(String str,int size,String logopath,String text)

    BufferedImage qrcodetext(String str,int size,int onColor,int offColor,String text) //获取指定尺寸、前景色、背景色及带文本的二维码图像数据
    BufferedImage qrcodetext(String str,int size,String text)

    /*---输出二进制数据---*/
    byte[] qrcode2bytes(String str,int size) //输出指定大小的二维码二进制数据
    byte[] qrcode2bytes(String str,int size,int onColor,int offColor)
    byte[] qrcodelogo2bytes(String str,int size,int onColor,int offColor,String logopath)
    byte[] qrcodelogo2bytes(String str,int size,int onColor,int offColor,String logopath,String text)
    byte[] qrcodelogo2bytes(String str,int size,String logopath)
    byte[] qrcodelogo2bytes(String str,int size,String logopath,String text)
    byte[] qrcodetext2bytes(String str,int size,int onColor,int offColor,String text)
    byte[] qrcodetext2bytes(String str,int size,String text)


    /*---直接输出到浏览端---*/
    void qrcodeOut(String str,int size)//浏览器输出指定大小的二维码，下同
    void qrcodeOut(String str,int size,String logo)
    void qrcodeOut(String str,int size,String logo,String text)
    void qrcodeOut(String str,int size,int onColor,int offColor)
    void qrcodeOut(String str,int size,int onColor,int offColor,String logo)
    void qrcodeOut(String str,int size,int onColor,int offColor,String logo,String text)
    void qrcodeOut(String str,int size,int onColor,int offColor,String logo,String text,boolean round,boolean transparent)

    void qrcodeTextOut(String str,int size,String text)//浏览器输出指定尺寸带文本的二维码
    void qrcodeTextOut(String str,int size,int onColor,int offColor,String text)

     2、解码
    String qrDecode(String filename)

压缩与解压

一、压缩
byte[] gzip(String str)
byte[] gzip(String str,String charset)
boolean zip(String srcFile,String zipFile)//srcFile:需要压缩的文件或目录 zipFile:压缩后保存路径及文件名

二、解压
String ungzip(byte[] gzstr)
String ungzip(byte[] gzstr,String charset)
boolean unzip(String zipFile,String desPath)//zipFile:需要解压的文件，desPath:解压到目标目录

图片验证码

1、字符验证码
/capacha //默认4位验证码
/capacha?n=x //x为数字，最小为1，输出指定长度为x的验证码
/capacha?e=1//排除1li0o这些易混淆字符
/*
以JPG格式输出图片
默认4位结果：
如n=6的结果：
*/

2、计算验证码
/capacha?t=1 //默认20以内加减法验证码
/capacha?t=1&n=x //x为数字，输出最大数字为x以内的加减法验证码
/*
以JPG格式输出图片
默认20以内结果：
如t=1&n=100的结果：
*/

3、交互验证码
/capacha?t=2 //默认4个汉字交互验证码
/capacha?t=2&n=x //x为数字，输出x个汉字验证码
/*
以JPG格式输出图片
默认4个汉字结果：
如t=2&n=8的结果：

t=3的结果：64随机位置点击验证
*/

前端HTML获取坐标方法：
<body>
<script type="text/javascript">
function verify(obj)
{ var e=window.event;
    var x=e.clientX-obj.offsetLeft;
var y=e.clientY-obj.offsetTop;
jc_$.request('/test/verifycha.htm','{"x":'+x+',"y":'+y+'}',function(res)
  {
   if(res=='true')
   {alert("验证成功");
   }
   else
   {alert("验证失败");
    obj.src="/capacha?t=2&n=8&ts="+new Date().getTime();
   }
  },'post'
);
}
</script>
<div style="margin-left:300px;margin-top:200px;"><img src="/capacha?t=2&n=8" onclick="verify(this)"/></div>
</body>

4、验证码获取
String verCode=session("verCode").toString();
String verCode=sess2str("verCode");
int verCode=sess2int("verCode");
int [] verCode=(int[])session("verCode");//交互式验证码

5、验证
/*验证后，无论成功失败，验证码将会删除，前端必须重新刷新验证码*/
boolean verifyCapacha(String verCode)//默认字符式验证码验证，返回true验证通过，返回false验证失败
boolean verifyCapacha(int verCode)//t=1计算式验证码结果验证，返回true验证通过，返回false验证失败
boolean verifyCapacha(int verX,int verY)//t=2交互式验证码验证，返回true验证通过，返回false验证失败
boolean verifyLetterPos(int posX,int posY)//t=3交互式验证码验证，返回true验证通过，返回false验证失败
6、清空验证码
void session("verCode",null)

时间日期

1、数字时间
int utctime()//utc时间,系统时间减去时区偏移和夏令时差
int time()//10位
int time(String datestr)//yyyy-MM-dd HH:mm:ss
int time(Date date)
long microtime()//13位
long microtime(String datestr)//yyyy-MM-dd HH:mm:ss
long microtime(Date date)
long nanotime()//14位
long utclongtime()//utc时间
long getTimeOffset()//获取该时间所在时区的时间偏移量
long getTimeRawOffset()//获取时间原始偏移量，该值不受夏令时的影响
long getDSTOffset()//获取夏令时差，在夏令时规则生效时，返回相对于标准时间提前的毫秒数，如果此时区不实施夏令时，则为 0
int afterYearsTime(int time,int years)//返回指定时间n年后的时间
long afterYearsTime(long time,int years)//返回指定时间n年后的时间
int beforeYearsTime(int time,int years)//返回指定时间n年前的时间
long beforeYearsTime(long time,int years)//返回指定时间n年前的时间
int afterMonthsTime(int time,int months)//返回指定时间n月后的时间
long afterMonthsTime(long time,int months)//返回指定时间n月后的时间
int beforeMonthsTime(int time,int months)//返回指定时间n月前的时间
long beforeMonthsTime(long time,int months)//返回指定时间n月前的时间
int afterDaysTime(int time,int days)//返回指定时间n天后的时间
long afterDaysTime(long time,int days)//返回指定时间n天后的时间
int beforeDaysTime(int time,int days)//返回指定时间n天前的时间
long beforeDaysTime(long time,int days)//返回指定时间n天前的时间

2、日期
String date()/返回当前日期，格式为：yyyy-MM-dd HH:mm:ss
String date(String format)
String date(long time,String format)
String date(long time)//格式默认：yyyy-MM-dd HH:mm:ss
String date(int time,format)
String date(int time)//格式默认：yyyy-MM-dd HH:mm:ss
Date getdate()//返回当前时间的日期类型
Date getdate(int time)//返回指定时间的日期类型
Date getdate(long time)//返回指定时间的日期类型
Date getdate(String timestr)//返回指定时间的日期类型 timestr格式为：yyyy-MM-dd HH:mm:ss
HashMap<String,Integer> dateinfo()//返回当前日期年(y)、月(m)、日(d)、时(h)、分(i)、秒(s)、星期(w)的数据结构
HashMap<String,Integer> dateinfo(Date dt)//返回指定日期年(y)、月(m)、日(d)、时(h)、分(i)、秒(s)、星期(w)的数据结构
HashMap<String,Integer> dateinfo(int time)//返回指定日期年(y)、月(m)、日(d)、时(h)、分(i)、秒(s)、星期(w)的数据结构
HashMap<String,Integer> dateinfo(long time)//返回指定日期年(y)、月(m)、日(d)、时(h)、分(i)、秒(s)、星期(w)的数据结构
HashMap<String,Integer> dateinfo(String datestr)//返回指定日期年(y)、月(m)、日(d)、时(h)、分(i)、秒(s)、星期(w)的数据结构

时间日期标识符：
      yyyy：年
      MM：月
      dd：日
      hh：1~12小时制(1-12)
      HH：24小时制(0-23)
      mm：分
      ss：秒
      S：毫秒
      E：星期几
      D：一年中的第几天
      F：一月中的第几个星期(会把这个月总共过的天数除以7)
      w：一年中的第几个星期
      W：一月中的第几星期(会根据实际情况来算)
      a：上下午标识
      k：和HH差不多，表示一天24小时制(1-24)。
      K：和hh差不多，表示一天12小时制(0-11)。
      z：表示时区
      Z: 表示时区，输出 +0800
      XXX：表示时间时区格式，输出+08:00
中间如果带字符用单引号引起来，如:yyyy-MM-dd'T'HH:mm:ssXXX 输出结果为：2017-01-12T22:14:16+08:00
3、星期
int week()//返回当日星期从星期日 - 星期六0-6表示
int week(Date dt)//返回指定日期星期

4、年月日、时分秒
int year()
int year(Date dt)
int month()//返回当月
int month(Date dt)//返回指定时间月份
int day()
int day(Date dt)
int hour()
int hour(Date dt)
int minute()
int minute(Date dt)
int second()
int second(Date dt)
int monthdays()//返回当前月一共有多少天数//2月平年28天，闰年29天，1、3、5、7、8、10、12月31天，4、6、9、11月30天
int monthdays(int year,int month)//返回某年某月一共有多少天数，公历
int monthdays(long time)
int monthdays(int time)
int monthdays(Date date)
int yeardays()//返回当前年一共有多少天数，公历，平年365，闰年366
int yeardays(int year)//返回某年一共有多少天数，公历，平年365，闰年366
int yeardays(long time)
int yeardays(int time)
int yeardays(Date date)
float intervalDays(int interval)//计算秒差的天数
float intervalDays(long interval)//计算毫秒差的天数
float intervalDays(int time1,time2)//计算两个时间相差多少天数
float intervalDays(long time1,long time2)
float intervalDays(Date date1,Date date2)
HashMap<String,Integer> intervalDHMS(int interval)//返回秒差的d:天数，h:小时，m:分钟，s:秒数
HashMap<String,Integer> intervalDHMS(long interval)//返回毫差的d:天数，h:小时，m:分钟，s:秒数
HashMap<String,Integer> intervalDHMS(int time1,int time2)
HashMap<String,Integer> intervalDHMS(long time1,long time2)
HashMap<String,Integer> intervalDHMS(Date date1,Date date2)
int weekofyear()//获取当前日期是一年中的第几周
int weekofyear(Date date)//获取指定日期是一年中的第几周
int weekofyear(int time)
int weekofyear(long time)
int weekofmonth()//获取当前日期是一月中的第几周
int weekofmonth(Date date)//获取指定日期是一月中的第几周
int weekofmonth(int time)
int weekofmonth(long time)
int dayofyear()//获取当前日期是一年中的第几天
int dayofyear(Date date)//获取指定日期是一年中的第几天
int dayofyear(int time)
int dayofyear(long time)

5、润年
boolean isleapyear(int year);//返回是否是润年

6、农历
String lunarDate(Date date)//返回指定日期的农历，结果如：2018年八月廿七
HashMap<String ,Integer> lunarInfo(Date date)//返回指定日期的农历结构，y:农历年，m:农历月,d:农历日，leapmonth:农历是否闰月，gy:年的天干，zy:年的地支，ya：年的生肖

7、时区
String getTimeZoneStr()//获取系统时区ID，如：Asia/Shanghai
TimeZone getTimeZone()//获取系统时区
TimeZone getTimeZone(String timezone)//根据字符ID转换成时区如：getTimeZone("Asia/Shanghai")
void setTimeZone(String timezone)//设置系统时区，参数为时区ID,如：setTimeZone("Asia/Shanghai")
void setTimeZone(TimeZone timezone)//设置系统时区

日志操作

日志保存位置为：temp/logs/
日志输出：
void log(String logmsg);//错误日志，会输出所在文件，类，方法及所在行号
void log(String type,String logmsg)；//type为：info,notice 只输出信息，不输出所在文件，类，方法行号

有效性验证

导入类：import org.jkas.utils.Valid;
boolean va lid(String regex,String str);//直接验证，参数一为正则表达式，参数2为要验证的字符串
Valid valid();//返回 valid对象
valid对象可用方法：
boolean check(String regex,String str)//通过自定义正则进行验证
boolean checkEmail(String email)//验证邮件地址格式
boolean checkIdCard(String idCard)//验证身份证号码
boolean checkMobile(String mobile)//验证手机号码
boolean checkMobile(String mobile,int country)//验证国际手机号码
boolean checkPhone(String phone)//验证电话号码
boolean checkChinese(String chinese)//验证中文
boolean checkLNC(String str)//验证字母或数字或中文
boolean checkURL(String url)//验证链接
boolean checkIpAddress(String ipAddress)//验证IP地址
boolean checkNumber(String str)//验证数字，不含小数
boolean checkDecimal(String str)//验证数字,含小数
boolean hasNumber(String str)//验证str里面是否有数字
boolean checkIn(String str,String strs)//包含检查，strs用逗号分隔的字符串
boolean checkIn(String str,String[] strs)

public String test(HashMap<String,String> params,HashMap<String,String>regstrs)//批量验证，只要有一个不符，返回该字段及验证关键字，符合返回空字符串""
public String test(String str,String regstr)//单个验证，不符，返回该字验证关键字，符合返回空字符串""
regstr可选择值为：冒号后面为自定义验证条件，多个验证关键字用|分开，多个条件情况用逗号隔开
number//数字，不含小数
decimal//数字，包含小数
chinese//中文
lt:n//小于,n是一个数字
let:n//小于等于,n是一个数字
gt:n//大于,n是一个数字
get:n//大于等于,n是一个数字
max:n//最大长度,n是一个数字
min:n//最小长度,n是一个数字
mobile:n//手机,n是一个数字（非必须）,0或86代表中国手机1开头，11位数字，其它相当于验证数字（3-18）位
email//邮件地址
require//必须，非空验证
eq:x//等于，x是一个字符串
in:x1,x2,x3,...//包含，x是一个字符串
between:n1,n2//两者这间，n是数字，大于等于第一个数字，小于第二个数字
lnc//字母、数字、中文验证
ip//验证ip地址
idno//验证身份证
url//验证url地址
custom:\d+//自定义正则
单个验证举例
valid().test("99","number|let:88");//验证不通过，返回let
valid().test("99","in:88,99,100");//验证通过，返回""
valid().test("99","between:200,300");//验证不通过，返回between

批量验证举例：
HashMap<String,String> params=new HashMap<String,String> ();
params.put("name","zhou");
params.put("sex",1);
HashMap<String,String> regs=new HashMap<String,String>();
regs.put("name","require|email");
regs.put("sex","in:1,2.5,3,7,9");
valid().test(params,regs);//验证不通过返回name.email

正则举例：
String regex="^[a-zA-Z0-9u4E00-u9FA5_]+$";//匹配数字、字母、中文及下划线
boolean isvalid=valid(regex,"abc");

正则规则见附件：正则表达式

PDF转图片

int pdfpages(String filepath)//获取pdf文件页数
boolean pdf2jpg(int page,String filepath,String savepath)//把pdf文件指定页保存为JPG图片，文件名包含在路径里
boolean pdf2jpg(int page,String filepath,String savepath,String savename)//把pdf文件指定页保存为JPG图片，文件名单独指定
boolean pdf2jpg(int page,float scale,String filepath,String savepath,String savename)//把pdf文件全部页保存为JPG图片
boolean pdf2jpgs(String filepath,String savepath,String savename)
boolean pdf2jpgs(float scale,String filepath,String savepath,String savename)
boolean pdf2png(int page,String filepath,String savepath)//把pdf文件指定页保存为PNG图片，文件名包含在路径里
boolean pdf2png(int page,String filepath,String savepath,String savename)//把pdf文件指定页保存为PNG图片，文件名单独指定
boolean pdf2png(int page,float scale,String filepath,String savepath,String savename)
boolean pdf2pngs(String filepath,String savepath,String savename)//把pdf文件全部页保存为PNG图片
boolean pdf2pngs(float scale,String filepath,String savepath,String savename)
BufferedImage pdf2img(int page,String pdfpath)//把pdf文件指定页转成为图片
BufferedImage pdf2img(int page,float scale,String pdfpath)//把pdf文件指定页转为为图片

pdf2jpgOut(int page,String pdfpath)//向浏览器直接输出pdf文件指定页图片
pdf2jpgOut(int page,float scale,String pdfpath)//向浏览器直接输出指定比例的pdf文件指定页jpg图片
pdf2imgOut(int page,float scale,String pdfpath,String type)//向浏览器直接输出指定比例的pdf文件指定页指定类型图片，type:jpg|png

序列号

String uuid()//全球唯一编号
long getGlobalSerialId()//全局递增序列号
String getGlobalSerialId(int num)//全局指定长度的递增序列号
String getGlobalSerialId(String dateformat)//全局指定日期格式前缀的递增序列号
String getGlobalSerialId(int num,String dateformat)//全局指定长度和日期格式前缀的递增序列号
long getSerialId(String key)//指定键名的递增序列号，key值如：order_sn,user_sn等，只要是字符串都行
String getSerialId(String key,int num)//指定键名和长度的递增序列号
String getSerialId(String key,String dateformat)//指定键名和日期格式前缀的递增序列号
String getSerialId(String key,int num,String dateformat)//指定键名长度和日期格式前缀的递增序列号
JavaScript

正向调用js

boolean jsinit(String jstr)//jstr:javascript文件路径或javascript字符串，如果是文件路径，必须以.js结尾
boolean jsinit(String[] jstrs)
boolean jsinitFile(String jsfile)//jsfile:javascript文件路径或；多个文件用逗号隔开
boolean jsinitFile(String[] jsfiles)//多个文件
String jscall(String method,Object param1,Object param2,...,Object paramn)//执行js方法
String eval(String str)//计算js表达式的值
举例：
字符串方式：
String jstr="function(a,b){return a+b}";
   jsinit(jstr);
   echo(jscall("add",1,2));

文件方式：
String jsfile="f:/a.js";
   jsinit(jsfile);
   echo(jscall("add",1,2));
   echo(jscall("getNum"));

f:/a.js内容如下：
function add(a,b)
{return a+getNum();
}
function getNum()
{var a=562;
return a;
}

逆向调用js

JavaScript里面调用框架函数方法：

前提：必须先经过正向调用步骤
jkas.函数名（参数...) 即可调用

如：
jkas.jmd5("123456");

可在JS文件调用的框架函数：
String jC(String k)//配置读取
String jsys(String k)//系统参数
String jgetCharset()//框架字符编码
void jlog(String logmsg)//日志写入
String jmd5(String str)//md5生成
String jsha(String str)//sha生成
String jget(String url)//网络get请求
String jpost(String url,String params)//网络post请求
Ucenter

Uclient

为了统一用户登录，特开发Uclient插件
先在配置文件对UC参数进行配置好才能使用
1、导入类
import org.jkas.uclient.Uclient;

2、实例化
Uclient()//所有参数自动从配置文件读取
void setIp(String ip)//设置客户端用户来源IP
void setType(int type)//接口方式，1为数据库接口，2为网络接口
void setAppid(String appid)//设置appid,由用户中心分配获得
void setAuthkey(String authkey)//设置通信密码
void setPrikey(String prikey)//设置通信密钥

int ver();//uclient版本号
String verName();//uclient版本名称

3、登录
HashMap<String,String> login(String username,String password)//传入用户名密码
返回值(json)：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-1,"msg":"invalid username"}//用户名无效
{"code":7,"msg":"wrong password"}//密码不正确
{"code":2,"msg":"username don't exists"}//用户不存在
{"code":1,"msg":"success","uid":"uid","user_id":"user_id","username":"username"}//登录成功，返回用户信息

4、注册
HashMap<String,String> register(String username,String password)//用户名和密码
HashMap<String,String> register(String username,String password,String mobile)//用户名、密码和手机号
HashMap<String,String> register(String username,String password,String mobile,String email)//用户名、密码、手机号和邮箱

返回值（json):
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-1,"msg":"invalid username"}//用户名无效
{"code":3,"msg":"mobile exists"}//手机号已经存在
{"code":5,"msg":"wrong mobile"}//手机号码格式不正确
{"code":4,"msg":"email exists"}//邮件地址已经存在
{"code":6,"msg":"wrong email"}//邮件格式不正确
{"code":-2,"msg":"failed"}//注册失败
{"code":2,"msg":"username exists"}//用户名已经存在
{"code":1,"msg":"success","uid":"nuid"}//注册成功

5、更新
HashMap<String,String> modify(String username,String newusername)
HashMap<String,String> modify(String username,String password,String oldpassword)
HashMap<String,String> modify(String username,String password,String oldpassword,String mobile)
HashMap<String,String> modify(String username,String password,String oldpassword,String mobile,String email)
HashMap<String,String> modify(String username,String password,String oldpassword,String mobile,String email,boolean force)//force为true时，强制修改，不用校验旧密码
HashMap<String,String> modify(String username,String newusername,String password,String oldpassword,String mobile,String email,boolean force)//force为true时，强制修改，不用校验旧密码

返回值：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":2,"msg":"username not found"}
{"code":3,"msg":"mobile exists"}
{"code":5,"msg":"wrong mobile"}
{"code":4,"msg":"email exists"}
{"code":6,"msg":"wrong email"}
{"code":8,"msg":"wrong old password"}
{"code":-2,"msg":"faild"}
{"code":1,"msg":"success"}

6、删除
HashMap<String,String> drop(String username)
返回值（json):
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-2,"msg":"failed"}
{"code":1,"msg":"success"}

7、查询
HashMap<String,String> check(String username)
HashMap<String,String> check(String value,String column) //value:值 column :列名（只能是username,mobiel,email 之一)

返回值：
{"code":-1,"msg":"invalid username"}
{"code":5,"msg":"wrong mobile"}
{"code":6,"msg":"wrong email"}
{"code":-3,"msg":"invalid check"}
{"code":1,"msg":"success","uid":uid,"username":"username","mobile":"mobile","email":"email"}
{"code":2,"msg":"column don't exists"}
{"code":0,"msg":"unknown error"}

Userver

接口描述

统一POST请求参数：appid,authkey 必须
appid:应用id
authkey:通信密码
sign:签名，签名规则下面第6点将会描述（用户应用启用验证签名选项才会进行验证）

1、登录请求接口：login

参数：
username //用户名
password //密码

返回值：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-1,"msg":"invalid username"}//用户名无效
{"code":7,"msg":"wrong password"}//密码不正确
{"code":2,"msg":"username d2on't exists"}//用户不存在
{"code":1,"msg":"success","user":{"uid":"uid","username":"username"}}//登录成功，返回用户信息

2、注册请求接口：register

参数：
username //用户名
password //密码
mobile //手机
email //邮件
ip //客户端IP地址

返回值：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-1,"msg":"invalid username"}//用户名无效
{"code":3,"msg":"mobile exists"}//手机号已经存在
{"code":5,"msg":"wrong mobile"}//手机号码格式不正确
{"code":4,"msg":"email exists"}//邮件地址已经存在
{"code":6,"msg":"wrong email"}//邮件格式不正确
{"code":-2,"msg":"failed"}//注册失败
{"code":2,"msg":"username exists"}//用户名已经存在
{"code":1,"msg":"success","user":{"uid":"nuid"}}//注册成功

3、修改请求接口：modify

参数：
username //用户名
newusername//新用户名
password //密码
oldpassword
mobile //手机
email //邮件
ip //客户端IP地址
force //是否强制修改 true|false

返回值：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":2,"msg":"username not found"}
{"code":3,"msg":"mobile exists"}
{"code":5,"msg":"wrong mobile"}
{"code":4,"msg":"email exists"}
{"code":6,"msg":"wrong email"}
{"code":8,"msg":"wrong old password"}"
{"code":-2,"msg":"failed"}
{"code":1,"msg":"success"}

4、删除请求接口：drop

参数：
username //用户名
ip //客户端IP地址

返回值：
{"code":-4,"msg":"invalid access"}//无效访问
{"code":-2,"msg":"failed"}
{"code":1,"msg":"success"}

5、查询请求接口：check

参数：
value //值
column //列名（只能是username,mobiel,email 之一)
ip //客户端IP地址

返回值：
{"code":-1,"msg":"invalid username"}
{"code":5,"msg":"wrong mobile"}
{"code":6,"msg":"wrong email"}
{"code":-3,"msg":"invalid check"}
{"code":1,"msg":"success","uid":uid,"username":"username","mobile":"mobile","email":"email"}
{"code":2,"msg":"column don't exists"}

6、签名规则
所有参数按参数名升序排列，进行md5后再进行RsaSignMd5签名
如：
请求参数是：username=abc&ip=192.168.1.1&password=123456&authkey=sswwer&appid=1
升序排列结果：sortstr="appid=1&authkey=sswwer&ip=192.168.1.1&password=123456&username=abc"
进行md5: mdrstr=md5(sortstr);
用密钥进行RsaSignMd5签名：RsaSignMd5（md5str,prikey）；

附录

HTTP状态码

什么是HTTP状态码？

当浏览者访问一个网页时，浏览者的浏览器会向网页所在服务器发出请求。当浏览器接收并显示网页前，此网页所在的服务器会返回一个包含HTTP状态码的信息头（server header）用以响应浏览器的请求。

HTTP状态码的英文为HTTP Status Code。

下面是常见的HTTP状态码：

200 - 请求成功
301 - 资源（网页等）被永久转移到其它URL
404 - 请求的资源（网页等）不存在
500 - 内部服务器错误

HTTP状态码分类

HTTP状态码由三个十进制数字组成，第一个十进制数字定义了状态码的类型，后两个数字没有分类的作用。HTTP状态码共分为5种类型：


分类	分类描述
1**	信息，服务器收到请求，需要请求者继续执行操作
2**	成功，操作被成功接收并处理
3**	重定向，需要进一步的操作以完成请求
4**	客户端错误，请求包含语法错误或无法完成请求
5**	服务器错误，服务器在处理请求的过程中发生了错误

HTTP状态码列表:


状态码	状态码英文名称	中文描述
100	Continue	继续。客户端应继续其请求
101	Switching Protocols	切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议，例如，切换到HTTP的新版本协议

200	OK	请求成功。一般用于GET与POST请求
201	Created	已创建。成功请求并创建了新的资源
202	Accepted	已接受。已经接受请求，但未处理完成
203	Non-Authoritative Information	非授权信息。请求成功。但返回的meta信息不在原始的服务器，而是一个副本
204	No Content	无内容。服务器成功处理，但未返回内容。在未更新网页的情况下，可确保浏览器继续显示当前文档
205	Reset Content	重置内容。服务器处理成功，用户终端（例如：浏览器）应重置文档视图。可通过此返回码清除浏览器的表单域
206	Partial Content	部分内容。服务器成功处理了部分GET请求

300	Multiple Choices	多种选择。请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择
301	Moved Permanently	永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替
302	Found	临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI
303	See Other	查看其它地址。与301类似。使用GET和POST请求查看
304	Not Modified	未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源
305	Use Proxy	使用代理。所请求的资源必须通过代理访问
306	Unused	已经被废弃的HTTP状态码
307	Temporary Redirect	临时重定向。与302类似。使用GET请求重定向

400	Bad Request	客户端请求的语法错误，服务器无法理解
401	Unauthorized	请求要求用户的身份认证
402	Payment Required	保留，将来使用
403	Forbidden	服务器理解请求客户端的请求，但是拒绝执行此请求
404	Not Found	服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
405	Method Not Allowed	客户端请求中的方法被禁止
406	Not Acceptable	服务器无法根据客户端请求的内容特性完成请求
407	Proxy Authentication Required	请求要求代理的身份认证，与401类似，但请求者应当使用代理进行授权
408	Request Time-out	服务器等待客户端发送的请求时间过长，超时
409	Conflict	服务器完成客户端的PUT请求是可能返回此代码，服务器处理请求时发生了冲突
410	Gone	客户端请求的资源已经不存在。410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置
411	Length Required	服务器无法处理客户端发送的不带Content-Length的请求信息
412	Precondition Failed	客户端请求信息的先决条件错误
413	Request Entity Too Large	由于请求的实体过大，服务器无法处理，因此拒绝请求。为防止客户端的连续请求，服务器可能会关闭连接。如果只是服务器暂时无法处理，则会包含一个Retry-After的响应信息
414	Request-URI Too Large	请求的URI过长（URI通常为网址），服务器无法处理
415	Unsupported Media Type	服务器无法处理请求附带的媒体格式
416	Requested range not satisfiable	客户端请求的范围无效
417	Expectation Failed	服务器无法满足Expect的请求头信息

500	Internal Server Error	服务器内部错误，无法完成请求
501	Not Implemented	服务器不支持请求的功能，无法完成请求
502	Bad Gateway	充当网关或代理的服务器，从远端服务器接收到了一个无效的请求
503	Service Unavailable	由于超载或系统维护，服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中
504	Gateway Time-out	充当网关或代理的服务器，未及时从远端服务器获取请求
505	HTTP Version not supported	服务器不支持请求的HTTP协议的版本，无法完成处理

正则表达式

正则表达式规则

元字符	描述
	将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\n”匹配。“ ”匹配换行符。序列“\”匹配“”而“(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“ ”或“ ”之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“ ”或“ ”之前的位置。
*	匹配前面的子表达式任意次。例如，zo能匹配“z”，“zo”以及“zoo”。等价于{0,}。
+	匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。
.点	匹配除“ ”之外的任何单个字符。要匹配包括“ ”在内的任何字符，请使用像“[sS]”的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“(”或“)”。
(?:pattern)	匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“(\|)”来组合一个模式的各个部分是很有用。例如“industr(?:y\|ies)”就是一个比“industry\|industries”更简略的表达式。
(?=pattern)	正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95\|98\|NT\|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95\|98\|NT\|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。
(?<=pattern)	反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95\|98\|NT\|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。
(?<!pattern)	反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95\|98\|NT\|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。
x\|y	匹配x或y。例如，“z\|food”能匹配“z”或“food”或"zood"(此处请谨慎)。“(z\|f)ood”则匹配“zood”或“food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
	匹配一个单词边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的就是匹配位置的）。例如，“er”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。
B	匹配非单词边界。“erB”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
cx	匹配由x指明的控制字符。例如，cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
d	匹配一个数字字符。等价于[0-9]。
D	匹配一个非数字字符。等价于[^0-9]。
f	匹配一个换页符。等价于x0c和cL。
	匹配一个换行符。等价于x0a和cJ。
	匹配一个回车符。等价于x0d和cM。
s	匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ f v]。
S	匹配任何可见字符。等价于[^ f v]。
	匹配一个制表符。等价于x09和cI。
v	匹配一个垂直制表符。等价于x0b和cK。
w	匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“x41”匹配“A”。“x041”则等价于“x04&1”。正则表达式中可以使用ASCII编码。
um	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)1”匹配两个连续的相同字符。
	标识一个八进制转义值或一个向后引用。如果之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
m	标识一个八进制转义值或一个向后引用。如果 m之前至少有nm个获得子表达式，则nm为向后引用。如果 m之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则 m将匹配八进制转义值nm。
ml	如果n为八进制数字（0-7），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，u00A9匹配版权符号（©）。
< >	匹配词（word）的开始（<）和结束（>）。例如正则表达式<the>能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
( )	将 ( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 1 到9 的符号来引用。
\|	将两个匹配条件进行逻辑“或”（Or）运算。例如正则表达式(him\|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。
+	匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意：这个元字符不是所有的软件都支持的。
?	匹配0或1个正好在它之前的那个字符。注意：这个元字符不是所有的软件都支持的。
{i} {i,j}	匹配指定数目的字符，这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]{3} 能够匹配字符"A"后面跟着正好3个数字字符的串，例如A123、A348等，但是不匹配A1234。而正则表达式[0-9]{4,6} 匹配连续的任意4个、5个或者6个数字

常用：

规则	正则表达式语法
一个或多个汉字	^[u0391-uFFE5]+$
邮政编码	^[1-9]d{5}$
QQ号码	^[1-9]d{4,10}$
邮箱	^[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}.){1,3}[a-zA-z-]{1,}$
用户名（字母开头 + 数字/字母/下划线）	^[A-Za-z][A-Za-z1-9_-]+$
手机号码	^1[3\|4\|5\|8][0-9]d{8}$
URL	^((http\|https)://)?([w-]+.)+[w-]+(/[w-./?%&=]*)?$
18位身份证号	^(d{6})(18\|19\|20)?(d{2})([01]d)([0123]d)(d{3})(d\|X\|x)?$

定时任务规则

格式： [秒]空格[分]空格[小时]空格[日]空格[月]空格[周]空格[年]|[类]空格[类方法]|[任务描述]

1.Seconds （秒）
2.Minutes（分）
3.Hours（小时）
4.Day-of-Month （天）
5.Month（月）
6.Day-of-Week （周）
7.Year（年）

例："0 0 12 ? * WED” 意思是：每个星期三的中午12点执行。

个别子表达式可以包含范围或者列表。例如：上面例子中的WED可以换成"MON-FRI"，"MON,WED,FRI"，甚至"MON-WED,SAT"。

子表达式范围：
1.Seconds (0~59)
2.Minutes (0~59)
3.Hours (0~23)
4.Day-of-Month (1~31,但是要注意有些月份没有31天)
5.Month (0~11，或者"JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV,DEC")
6.Day-of-Week (1~7,1=SUN 或者"SUN, MON, TUE, WED, THU, FRI, SAT”)
7.Year (1970~2099)

Cron表达式的格式：秒分时日月周年(可选)。
字段名              允许的值                    允许的特殊字符
秒                     0-59                           , - * /
分                     0-59                           , - * /
小时                  0-23                           , - * /
日                     1-31                            , - * ? / L W C
月                     1-12 or JAN-DEC        , - * /
周几                  1-7 or SUN-SAT         , - * ? / L C #
年(可选字段)     empty                         1970-2099 , - * /

字符含义：

* ：代表所有可能的值。因此，“*”在Month中表示每个月，在Day-of-Month中表示每天，在Hours表示每小时

- ：表示指定范围。

, ：表示列出枚举值。例如：在Minutes子表达式中，“5,20”表示在5分钟和20分钟触发。

/ ：被用于指定增量。例如：在Minutes子表达式中，“0/15”表示从0分钟开始，每15分钟执行一次。"3/20"表示从第三分钟开始，每20分钟执行一次。和"3,23,43"（表示第3，23，43分钟触发）的含义一样。

? ：用在Day-of-Month和Day-of-Week中，指“没有具体的值”。当两个子表达式其中一个被指定了值以后，为了避免冲突，需要将另外一个的值设为“?”。例如：想在每月20日触发调度，不管20号是星期几，只能用如下写法：0 0 0 20 * ?，其中最后以为只能用“?”，而不能用“*”。

L ：用在day-of-month和day-of-week字串中。它是单词“last”的缩写。它在两个子表达式中的含义是不同的。
在day-of-month中，“L”表示一个月的最后一天，一月31号，3月30号。
在day-of-week中，“L”表示一个星期的最后一天，也就是“7”或者“SAT”
如果“L”前有具体内容，它就有其他的含义了。例如：“6L”表示这个月的倒数第六天。“FRIL”表示这个月的最后一个星期五。
注意：在使用“L”参数时，不要指定列表或者范围，这样会出现问题。

W ：“Weekday”的缩写。只能用在day-of-month字段。用来描叙最接近指定天的工作日（周一到周五）。例如：在day-of-month字段用“15W”指“最接近这个月第15天的工作日”，即如果这个月第15天是周六，那么触发器将会在这个月第14天即周五触发；如果这个月第15天是周日，那么触发器将会在这个月第 16天即周一触发；如果这个月第15天是周二，那么就在触发器这天触发。注意一点：这个用法只会在当前月计算值，不会越过当前月。“W”字符仅能在 day-of-month指明一天，不能是一个范围或列表。也可以用“LW”来指定这个月的最后一个工作日，即最后一个星期五。

# ：只能用在day-of-week字段。用来指定这个月的第几个周几。例：在day-of-week字段用"6#3" or "FRI#3"指这个月第3个周五（6指周五，3指第3个）。如果指定的日期不存在，触发器就不会触发。

表达式例子：

0 * * * * ? 每1分钟触发一次
0 0 * * * ? 每天每1小时触发一次
0 0 10 * * ? 每天10点触发一次
0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发
0 30 9 1 * ? 每月1号上午9点半
0 15 10 15 * ? 每月15日上午10:15触发

*/5 * * * * ? 每隔5秒执行一次
0 */1 * * * ? 每隔1分钟执行一次
0 0 5-15 * * ? 每天5-15点整点触发
0 0/3 * * * ? 每三分钟触发一次
0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发
0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发
0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

0 0 12 ? * WED 表示每个星期三中午12点
0 0 17 ? * TUES,THUR,SAT 每周二、四、六下午五点
0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发
0 15 10 ? * MON-FRI 周一至周五的上午10:15触发

0 0 23 L * ? 每月最后一天23点执行一次
0 15 10 L * ? 每月最后一日的上午10:15触发
0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发

0 15 10 * * ? 2025 2025年的每天上午10:15触发
0 15 10 ? * 6L 2022-2025 2022年至2025年的每月的最后一个星期五上午10:15触发
0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

数字签名介绍

RSA/DSA/ECDSA数字签名
RSA

RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。
算法分类信息：
算法密钥长度默认长度签名长度实现的方
MD2withRSA 512-65536
（64的整数倍） 1024 同密钥 JDK
MD5withRSA 同上 1024 同密钥 JDK
SHA1withRSA … 1024 同密钥 JDK
SHA224withRSA … 2048 同密钥 BC
SHA256withRSA … 2048 同密钥 BC
SHA384withRSA … 2048 同密钥 BC
SHA512withRSA … 2048 同密钥 BC
RIPEMD128withRSA
2048 同密钥 BC
RIPEMD160withRSA 同上 2048 同密钥 BC

DSA:

DSA是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSfS(DigitalSignature Standard)。

DSA是基于整数有限域离散对数难题的，其安全性与RSA相比差不多。DSA的一个重要特点是两个素数公开，这样，当使用别人的p和q时，即使不知道私钥，你也能确认它们是否是随机产生的，还是作了手脚。RSA却做不到。

算法分类信息：

算法	密钥长度	默认长度	签名长度	实现的方
SHA1withDSA	512-65536 （64的整数倍）	1024	同密钥	JDK
SHA224withDSA	同上	1024	同密钥	BC
SHA256withDSA	…	1024	同密钥	BC
SHA384withDSA	…	1024	同密钥	BC
SHA512withDSA	…	1024	同密钥	BC

ECC算法（Elliptic curve cryptography，椭圆曲线密码学）

ECDSA签名

基于ECC与DSA签名算法分类信息，ECDSA(elliptic curve digital signature algorithm) 椭圆曲线数字签名算法：速度快，强度高，签名短

算法	密钥长度	默认长度	签名长度	实现的方
NONEwithECDSA	112-571	256	128	JDK/BC
RIPEMD160withECDSA	同上	256	160	BC
SHA1withECDSA	...	256	160	JDK/BC
SHA224withECDSA	...	256	224	BC
SHA256withECDSA	...	256	256	JDK/BC
SHA384withECDSA	...	256	384	JDK/BC
SHA512withECDSA	...	256	512	JDK/BC

WebSocket知识

一、websocket与http

WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）

首先HTTP有 1.1 和 1.0 之说，也就是所谓的 keep-alive ，把多个HTTP请求合并为一个，但是 Websocket 其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充可以通过这样一张图理解

有交集，但是并不是全部。

另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=

再简单来说，层级不一样。

二、Websocket是什么样的协议，具体有什么优点

首先，Websocket是一个持久化的协议，相对于HTTP这种非持久的协议来说。简单的举个例子吧，用目前应用比较广泛的PHP生命周期来解释。

HTTP的生命周期通过 Request 来界定，也就是一个 Request 一个 Response ，那么在 HTTP1.0 中，这次HTTP请求就结束了。

在HTTP1.1中进行了改进，使得有一个keep-alive，也就是说，在一个HTTP连接中，可以发送多个Request，接收多个Response。但是请记住 Request = Response，在HTTP中永远是这样，也就是说一个request只能有一个response。而且这个response也是被动的，不能主动发起。

那么跟Websocket有什么关系呢？

首先Websocket是基于HTTP协议的，或者说借用了HTTP的协议来完成一部分握手。

首先我们来看个典型的 Websocket 握手

GET /chat HTTP/1.1Host: server.example.comUpgrade: websocketConnection: UpgradeSec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==Sec-WebSocket-Protocol: chat, superchatSec-WebSocket-Version: 13Origin: http://example.com

熟悉HTTP的童鞋可能发现了，这段类似HTTP协议的握手请求中，多了几个东西。

Upgrade: websocketConnection: Upgrade

这个就是Websocket的核心了，告诉 Apache 、 Nginx 等服务器：注意啦，我发起的是Websocket协议，不是那个HTTP。

Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==Sec-WebSocket-Protocol: chat, superchatSec-WebSocket-Version: 13

首先， Sec-WebSocket-Key 是一个 Base64 encode 的值，这个是浏览器随机生成的，告诉服务器：要验证是不是真的是Websocket。

然后， Sec_WebSocket-Protocol 是一个用户定义的字符串，用来区分同URL下，不同的服务所需要的协议。

最后， Sec-WebSocket-Version 是告诉服务器所使用的 Websocket Draft （协议版本），在最初的时候，Websocket协议还在 Draft 阶段，各种奇奇怪怪的协议都有，而且还有很多期奇奇怪怪不同的东西，什么Firefox和Chrome用的不是一个版本之类的，当初Websocket协议太多可是一个大难题。

然后服务器会返回下列东西，表示已经接受到请求，成功建立Websocket啦！

HTTP/1.1 101 Switching ProtocolsUpgrade: websocketConnection: UpgradeSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=Sec-WebSocket-Protocol: chat

这里开始就是HTTP最后负责的区域了，告诉客户，我已经成功切换协议啦~

Upgrade: websocketConnection: Upgrade

依然是固定的，告诉客户端即将升级的是 Websocket 协议，而不是mozillasocket，lurnarsocket或者shitsocket。

然后， Sec-WebSocket-Accept 这个则是经过服务器确认，并且加密过后的 Sec-WebSocket-Key 。服务器：好啦好啦，知道啦，给你看我的ID CARD来证明行了吧。。

后面的， Sec-WebSocket-Protocol 则是表示最终使用的协议。

至此，HTTP已经完成它所有工作了，接下来就是完全按照Websocket协议进行了。

三、数据传输

客户端和服务器连接成功后，就可以进行通信了，通信协议格式是WebSocket格式，服务器端采用Tcp Socket方式接收数据，进行解析，协议格式如下：

第一个字节

FIN:1位，用于描述消息是否结束，如果为1则该消息为消息尾部,如果为零则还有后续数据包;

uint8_t fin = (uint8_t)msg[pos] >> 7;

RSV1,RSV2,RSV3,各1位，用于扩展定义的,如果没有扩展约定的情况则必须为0

OPCODE:4位，用于表示消息接收类型，如果接收到未知的opcode，接收端必须关闭连接。

uint8_t opcode = msg[pos] & 0x0f;

0x0表示附加数据帧
0x1表示文本数据帧
0x2表示二进制数据帧
0x3-7暂时无定义，为以后的非控制帧保留
0x8表示连接关闭
0x9表示ping
0xA表示pong
0xB-F暂时无定义，为以后的控制帧保留

第二个字节

MASK:1位，用于标识PayloadData是否经过掩码处理，客户端发出的数据帧需要进行掩码处理，所以此位是1。数据需要解码

uint8_t mask = (uint8_t)msg[pos] >> 7;

PayloadData的长度：7位，7+16位，7+64位
如果其值在0-125，则是payload的真实长度。
如果值是126，则后面2个字节形成的16位无符号整型数的值是payload的真实长度。注意，网络字节序，需要转换。
如果值是127，则后面8个字节形成的64位无符号整型数的值是payload的真实长度。注意，网络字节序，需要转换。
长度表示遵循一个原则，用最少的字节表示长度（我理解是尽量减少不必要的传输）。举例说，payload真实长度是124，在0-125之间，必须用前7位表示；不允许长度1是126或127，然后长度2是124，这样违反原则。

RESTFul知识

REST（英文：Representational State Transfer，简称REST）描述了一个架构样式的网络系统，比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中，Roy Fielding是 HTTP 规范的主要编写者之一。在目前主流的三种Web服务交互方案中，REST相比于SOAP（Simple Object Access protocol，简单对象访问协议）以及XML-RPC更加简单明了，无论是对URL的处理还是对Payload的编码，REST都倾向于用更加简单轻量的方法设计和实现。值得注意的是REST并没有一个明确的标准，而更像是一种设计的风格。

REST全称是Resource REpresentational State Transfer，中文翻译是表现层状态转移，理解起来很困难。用一句话就是说：URL定位资源通过HTTP动词（GET,POST,DELETE,DETC）描述操作。REST是一种架构风格，公司或者个人建立API是都要遵守的一种规则/风格，当然也有其他的规则可以使用。下面是REST全称中每个单词的含义：

        （1）Transfer：通俗来讲就是：资源在网络中以某种表现形式进行状态转移。分解开来：
        （2）Resource：资源，即数据（前面说过网络的核心）。比如 newsfeed，friends等；
        （3）Representational：某种表现形式，比如用JSON，XML，JPEG等；
        （4） State Transfer：状态变化。通过HTTP动词实现。

REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。
Web 应用程序最重要的 REST 原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。

在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有：应用程序对象、数据库记录、算法等等。每个资源都使用 URI (Universal Resource Identifier) 得到一个唯一的地址。所有资源都共享统一的接口，以便在客户端和服务器之间传输状态。使用的是标准的 HTTP 方法，比如 GET、PUT、POST 和 DELETE。Hypermedia 是应用程序状态的引擎，资源表示通过超链接互联。

对于资源的具体操作类型，由HTTP动词表示。

常用的HTTP动词有下面五个（括号里是对应的SQL命令）。

GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。
PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源。

还有两个不常用的HTTP动词。

HEAD：获取资源的元数据。
OPTIONS：获取信息，关于资源的哪些属性是客户端可以改变的。

下面是一些例子。

GET /zoos：列出所有动物园
POST /zoos：新建一个动物园
GET /zoos/ID：获取某个指定动物园的信息
PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
DELETE /zoos/ID：删除某个动物园
GET /zoos/ID/animals：列出某个指定动物园的所有动物
DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物

一个开发效率堪比PHP的高效JAVA WEB框架！

不同舍入模式下的舍入操作汇总