语源科技BlogJava-李春生

mysql 中sql 语句查询今天、昨天、7天、近30天、本月、上一月数据

李春生 — Fri, 21 Jan 2011 05:40:00 GMT

今天

select * from 表名 where to_days(时间字段名) = to_days(now());

昨天

SELECT * FROM 表名 WHERE TO_DAYS( NOW( ) ) - TO_DAYS( 时间字段名) <= 1

7天

SELECT * FROM 表名 where DATE_SUB(CURDATE(), INTERVAL 7 DAY) <= date(时间字段名)

近30天

SELECT * FROM 表名 where DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= date(时间字段名)

本月

SELECT * FROM 表名 WHERE DATE_FORMAT( 时间字段名, '%Y%m' ) = DATE_FORMAT( CURDATE( ) , '%Y%m' )

上一月

SELECT * FROM 表名 WHERE PERIOD_DIFF( date_format( now( ) , '%Y%m' ) , date_format( 时间字段名, '%Y%m' ) ) =1

李春生 2011-01-21 13:40 发表评论

mysql date_format　按不同时间单位进行分组统计

李春生 — Fri, 21 Jan 2011 05:40:00 GMT

DATE_FORMAT(date,format)
根据format字符串格式化date值。下列修饰符可以被用在format字符串中：
%M     月名字(January……December)
%W     星期名字(Sunday……Saturday)
%D     有英语前缀的月份的日期(1st,   2nd,   3rd,   等等。）
%Y     年,   数字,   4   位
%y     年,   数字,   2   位
%a     缩写的星期名字(Sun……Sat)
%d     月份中的天数,   数字(00……31)
%e     月份中的天数,   数字(0……31)
%m     月,   数字(01……12)
%c     月,   数字(1……12)
%b     缩写的月份名字(Jan……Dec)
%j     一年中的天数(001……366)
%H     小时(00……23)
%k     小时(0……23)
%h     小时(01……12)
%I     小时(01……12)
%l     小时(1……12)
%i     分钟,   数字(00……59)
%r     时间,12   小时(hh:mm:ss   [AP]M)
%T     时间,24   小时(hh:mm:ss)
%S     秒(00……59)
%s     秒(00……59)
%p     AM或PM
%w     一个星期中的天数(0=Sunday   ……6=Saturday   ）
%U     星期(0……52),   这里星期天是星期的第一天
%u     星期(0……52),   这里星期一是星期的第一天
%%     一个文字“%”。

所有的其他字符不做解释被复制到结果中。

mysql>   select   DATE_FORMAT('1997-10-04   22:23:00',   '%W   %M   %Y');
                  ->   'Saturday   October   1997'
mysql>   select   DATE_FORMAT('1997-10-04   22:23:00',   '%H:%i:%s');
                  ->   '22:23:00'
mysql>   select   DATE_FORMAT('1997-10-04   22:23:00',
                                                      '%D   %y   %a   %d   %m   %b   %j');
                  ->   '4th   97   Sat   04   10   Oct   277'
mysql>   select   DATE_FORMAT('1997-10-04   22:23:00',
                                                      '%H   %k   %I   %r   %T   %S   %w');
                  ->   '22   22   10   10:23:00   PM   22:23:00   00   6'

, '%Y %m'

李春生 2011-01-21 13:40 发表评论

FusionCharts 的XML标签属性

李春生 — Fri, 21 Jan 2011 03:20:00 GMT

FusionCharts 的XML标签属性
FusionCharts 的 XML标签属性有一下四种数据类型
* Boolean - 布尔类型，只能为1或者0。例如：
* Number - 数字类型，只能为数字。例如：
* String - 字符串类型，只能为字符串。例如：
* Hex Color Code - 十六进制颜色代码，前边没有’#’.例如：

XML中的标签和属性有：
所具有的属性
flash背景参数：
* bgColor=”HexColorCode” : 设置flash的背景颜色
* bgAlpha=”NumericalValue(0-100)” : 设置背景的透明度
* bgSWF=”Path of SWF File” : 设置一个外部的Flash 为flash的背景
图表背景参数：
* canvasBgColor=”HexColorCode” : 设置图表背景的颜色
* canvasBaseColor=”HexColorCode” : 设置图表基部的颜色
* canvasBaseDepth=”Numerical Value” : 设置图表基部的高度
* canvasBgDepth=”Numerical Value” : 设置图表背景的深度
* showCanvasBg=”1/0″ : 设置是否显示图表背景
* showCanvasBase=”1/0″ : 设置是否显示图表基部
图表和轴的标题
* caption=”String” : 图表上方的标题
* subCaption=”String” : 图表上方的副标题
* xAxisName= “String” : X轴的名字
* yAxisName= “String” : y轴的名字
图表数量值的限制
* yAxisMinValue=”value”: y轴最小值
* yAxisMaxValue=”value”: y舟最大值
通用参数
* shownames=”1/0″ : 设置是否在x轴下显示里指定的name
* showValues=”1/0″ : 设置是否在柱型图或饼型图上显示数据的值
* showLimits=”1/0″ : 设置是否在图表的y轴坐标上显示最大最小的数据值
* rotateNames=”1/0″ : 设置x轴下的name 是水平显示还是垂直显示
* animation=”1/0″ : 设置柱型图的显示是否是动画显示
字体属性
* baseFont=”FontName” : 设置字体样式
* baseFontSize=”FontSize” : 设置字体大小
* baseFontColor=”HexColorCode” : 设置字体颜色
* outCnvBaseFont = “FontName” : 设置图表外侧的字体样式
* outCnvBaseFontSze=”FontSize” : 设置图表外侧的字体大小
* outCnvBaseFontColor=”HexColorCode”: 设置图表外侧的字体颜色
数字格式选项
* numberPrefix=”$” : 设置数据值的前缀
* numberSuffix=”p.a” : 设置数据值的后缀（如果是特殊字符，需要使用URL Encode重编码）
* formatNumber=”1/0″ : 设置是否格式化数据
* formatNumberScale=”1/0″ : 设置是否用“K”来代表千，“M”来代表百万
* decimalSeparator=”.” : 用指定的字符来代替小数点
* thousandSeparator=”,” : 用指定的字符来代替千位分隔符
* decimalPrecision=”2″ : 设置十进制的精度
* divLineDecimalPrecision=”2″: 设置y轴数值的小数位数
* limitsDecimalPrecision=”2″ : 设置y轴的最大最小值的小数位数
水平分隔线
* numdivlines=”NumericalValue” : 设置水平分隔线的数量
* divlinecolor=”HexColorCode” : 设置水平分隔线的颜色
* divLineThickness=”NumericalValue” : 设置水平分隔线的宽度
* divLineAlpha=”NumericalValue0-100″ : 设置水平分隔线的透明度
* showDivLineValue=”1/0″ : 设置是否显示水平分隔线的数值
鼠标旋停参数
* showhovercap=”1/0″ : 显示是否激活鼠标旋停效果
* hoverCapBgColor=”HexColorCode” : 设置鼠标旋停效果的背景颜色
* hoverCapBorderColor=”HexColorCode” : 设置鼠标旋停效果的边框颜色
* hoverCapSepChar=”Char” : 设置鼠标旋停后显示的文本中的分隔符号
图表边距的设置
* chartLeftMargin=”Numerical Value (in pixels)” : 设置图表左边距
* chartRightMargin=”Numerical Value (in pixels)” : 设置图表右边距
* chartTopMargin=”Numerical Value (in pixels)” : 设置图表上边距
* chartBottomMargin=”Numerical Value (in pixels)” : 设置图表下边距
Zero Plane
The zero plane is a 3D plane that signifies the 0 position on the chart. If there are no negative numbers on the chart, you won’t see a visible zero plane.
* zeroPlaneShowBorder=”1/0″ : Whether the border of a 3D zero plane would be plotted or not.
* zeroPlaneBorderColor=”Hex Code” : If the border is to be plotted, this attribute sets the border color for the plane.
* zeroPlaneColor=”Hex Code” : The intended color for the zero plane.
* zeroPlaneAlpha=”Numerical Value 0-100″ : The intended transparency for the zero plane.

所具有的属性
* name=”string” : 设置在图表中体现出来的名字
Example:
* value=”NumericalValue” : 设置在图表中各个名字想对应的值
Example:
* color=”HexCode” : 设置在图表中相对应的柱行图的颜色
Example:
* hoverText=”String value” : 设置鼠标旋停在相对应的柱行图上出现的文本内容
Example:
* link=”URL” : 设置该柱行图的链接地址（需要URL Encode重编码）
Example:
* alpha=”Numerical Value 0-100″ : 设置在图表中相对应的柱行图的透明度
Example:
* showName=”1″ : 设置在是否显示图表中相对应的柱行图的name
Example :

功能特性
animation                    是否动画显示数据，默认为1(True)
showNames                    是否显示横向坐标轴(x轴)标签名称
rotateNames                是否旋转显示标签，默认为0(False):横向显示
showValues                    是否在图表显示对应的数据值，默认为1(True)
yAxisMinValue                指定纵轴(y轴)最小值，数字
yAxisMaxValue                 指定纵轴(y轴)最小值，数字
showLimits                    是否显示图表限值(y轴最大、最小值)，默认为1(True)

图表标题和轴名称
caption                    图表主标题
subCaption                    图表副标题
xAxisName                    横向坐标轴(x轴)名称
yAxisName                    纵向坐标轴(y轴)名称

图表和画布的样式
bgColor                    图表背景色，6位16进制颜色值
canvasBgColor                画布背景色，6位16进制颜色值
canvasBgAlpha                画布透明度，[0-100]
canvasBorderColor            画布边框颜色，6位16进制颜色值
canvasBorderThickness        画布边框厚度，[0-100]
shadowAlpha                投影透明度，[0-100]
showLegend                    是否显示系列名，默认为1(True)

字体属性
baseFont                    图表字体样式
baseFontSize                图表字体大小
baseFontColor                图表字体颜色，6位16进制颜色值
outCnvBaseFont                图表画布以外的字体样式
outCnvBaseFontSize            图表画布以外的字体大小
outCnvBaseFontColor        图表画布以外的字体颜色，6位16进制颜色值

分区线和网格
numDivLines                画布内部水平分区线条数，数字
divLineColor                水平分区线颜色，6位16进制颜色值
divLineThickness            水平分区线厚度，[1-5]
divLineAlpha                水平分区线透明度，[0-100]
showAlternateHGridColor    是否在横向网格带交替的颜色，默认为0(False)
alternateHGridColor        横向网格带交替的颜色，6位16进制颜色值
alternateHGridAlpha        横向网格带的透明度，[0-100]
showDivLineValues            是否显示Div行的值，默认？？
numVDivLines                画布内部垂直分区线条数，数字
vDivLineColor                垂直分区线颜色，6位16进制颜色值
vDivLineThickness            垂直分区线厚度，[1-5]
vDivLineAlpha                垂直分区线透明度，[0-100]
showAlternateVGridColor    是否在纵向网格带交替的颜色，默认为0(False)
alternateVGridColor        纵向网格带交替的颜色，6位16进制颜色值
alternateVGridAlpha        纵向网格带的透明度，[0-100]

数字格式
numberPrefix                增加数字前缀
numberSuffix                增加数字后缀    % 为 '%25'
formatNumberScale        是否格式化数字,默认为1(True),自动的给你的数字加上K（千）或M（百万）；若取0,则不加K或M
decimalPrecision            指定小数位的位数，[0-10]    例如：='0' 取整
divLineDecimalPrecision    指定水平分区线的值小数位的位数，[0-10]
limitsDecimalPrecision        指定y轴最大、最小值的小数位的位数，[0-10]
formatNumber                逗号来分隔数字(千位，百万位),默认为1(True)；若取0,则不加分隔符
decimalSeparator            指定小数分隔符,默认为'.'
thousandSeparator            指定千分位分隔符,默认为','

Tool-tip/Hover标题
showhovercap                是否显示悬停说明框，默认为1(True)
hoverCapBgColor            悬停说明框背景色，6位16进制颜色值
hoverCapBorderColor        悬停说明框边框颜色，6位16进制颜色值
hoverCapSepChar            指定悬停说明框内值与值之间分隔符,默认为','

折线图的参数
lineThickness                折线的厚度
anchorRadius                折线节点半径，数字
anchorBgAlpha                折线节点透明度，[0-100]
anchorBgColor                折线节点填充颜色，6位16进制颜色值
anchorBorderColor            折线节点边框颜色，6位16进制颜色值

Set标签使用的参数
value                        数据值
color                        颜色
link                        链接（本窗口打开[Url]，新窗口打开[n-Url]，调用JS函数[JavaScript:函数]）
name                        横向坐标轴标签名称

李春生 2011-01-21 11:20 发表评论

mysql常用命令

李春生 — Fri, 21 Jan 2011 03:17:00 GMT

1.Linux系统下启动MySQL的命令：

mysqladmin start

/ect/init.d/mysql start (前面为mysql的安装路径)

2.linux下重启mysql的命令：

mysqladmin restart

/ect/init.d/mysql restart (前面为mysql的安装路径)

3.linux下关闭mysql的命令：

mysqladmin shutdown

/ect/init.d/mysql shutdown (前面为mysql的安装路径)

4.连接本机上的mysql：

进入目录mysql\bin，再键入命令mysql -uroot -p，回车后提示输入密码。

退出mysql命令：exit（回车）

5.修改mysql密码：

mysqladmin -u用户名 -p旧密码 password 新密码

或进入mysql命令行SET PASSWORD FOR root=PASSWORD("root");

6.增加新用户。（注意：mysql环境中的命令后面都带一个分号作为命令结束符）

grant select on 数据库.* to 用户名@登录主机 identified by "密码"

如增加一个用户test密码为123，让他可以在任何主机上登录，并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入mysql，然后键入以下命令：

grant select,insert,update,delete on *.* to " Identified by "123";

二、有关MySQL数据库方面的操作

必须首先登录到mysql中，有关操作都是在mysql的提示符下进行，而且每个命令以分号结束

1、显示数据库列表。

show databases;

2、显示库中的数据表：

use mysql；／／打开库

show tables;

3、显示数据表的结构：

describe 表名;

4、建库：

create database 库名;

5、建表：

use 库名；

create table 表名(字段设定列表)；

6、删库和删表:

drop database 库名;

drop table 表名；

7、将表中记录清空：

delete from 表名;

8、显示表中的记录：

select * from 表名;

9、编码的修改

如果要改变整个mysql的编码格式：

启动mysql的时候，mysqld_safe命令行加入

--default-character-set=gbk

如果要改变某个库的编码格式：在mysql提示符后输入命令

alter database db_name default character set gbk;

三、数据的导入导出

1、文本数据转到数据库中

文本数据应符合的格式：字段数据之间用tab键隔开，null值用来代替。例：

1 name duty 2006-11-23

数据传入命令 load data local infile "文件名" into table 表名;

2、导出数据库和表

mysqldump --opt news > news.sql（将数据库news中的所有表备份到news.sql文件，news.sql是一个文本文件，文件名任取。）

mysqldump --opt news author article > author.article.sql（将数据库news中的author表和article表备份到author.article.sql文件， author.article.sql是一个文本文件，文件名任取。）

mysqldump --databases db1 db2 > news.sql（将数据库dbl和db2备份到news.sql文件，news.sql是一个文本文件，文件名任取。）

mysqldump -h host -u user -p pass --databases dbname > file.dump

就是把host上的以名字user，口令pass的数据库dbname导入到文件file.dump中

mysqldump --all-databases > all-databases.sql（将所有数据库备份到all-databases.sql文件，all-databases.sql是一个文本文件，文件名任取。）

3、导入数据

mysql < all-databases.sql（导入数据库）

mysql>source news.sql;（在mysql命令下执行，可导入表）

一、连接MySQL

格式： mysql -h主机地址 -u用户名－p用户密码

1、例1：连接到本机上的MYSQL。

首先在打开DOS窗口，然后进入目录 mysqlbin，再键入命令mysql -uroot -p，回车后提示你输密码，如果刚安装好MYSQL，超级用户root是没有密码的，故直接回车即可进入到MYSQL中了，MYSQL的提示符是： mysql>。

2、例2：连接到远程主机上的MYSQL。假设远程主机的IP为：110.110.110.110，用户名为root,密码为abcd123。则键入以下命令：

mysql -h110.110.110.110 -uroot -pabcd123

（注:u与root可以不用加空格，其它也一样）

3、退出MYSQL命令： exit （回车）。

二、修改密码

格式：mysqladmin -u用户名 -p旧密码 password 新密码

1、例1：给root加个密码ab12。首先在DOS下进入目录mysqlbin，然后键入以下命令：

mysqladmin -uroot -password ab12

注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。

2、例2：再将root的密码改为djg345。

mysqladmin -uroot -pab12 password djg345

三、增加新用户。（注意：和上面不同，下面的因为是MySQL环境中的命令，所以后面都带一个分号作为命令结束符）

格式：grant select on 数据库.* to 用户名@登录主机 identified by \"密码\"

例1、增加一个用户test1密码为abc，让他可以在任何主机上登录，并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入MySQL，然后键入以下命令：

grant select,insert,update,

delete on *.* to test1@\"%\" Identified by \"abc\";

但例1增加的用户是十分危险的，你想如某个人知道test1的密码，那么他就可以在internet上的任何一台电脑上登录你的MySQL数据库并对你的数据可以为所欲为了，解决办法见例2。

例2、增加一个用户test2密码为abc,让他只可以在localhost上登录，并可以对数据库mydb进行查询、插入、修改、删除的操作（localhost指本地主机，即MySQL数据库所在的那台主机），这样用户即使用知道test2的密码，他也无法从internet上直接访问数据库，只能通过MySQL主机上的web页来访问。

grant select,insert,update,

delete on mydb.* to test2@localhost identified by \"abc\";

如果你不想test2有密码，可以再打一个命令将密码消掉。

grant select,insert,update,delete on mydb

.* to test2@localhost identified by \"\";

在上面讲了登录、增加用户、密码更改等问题。下面我们来看看MySQL中有关数据库方面的操作。注意：你必须首先登录到MySQL中，以下操作都是在MySQL的提示符下进行的，而且每个命令以分号结束。

一、操作技巧

1、如果你打命令时，回车后发现忘记加分号，你无须重打一遍命令，只要打个分号回车就可以了。也就是说你可以把一个完整的命令分成几行来打，完后用分号作结束标志就完成。

2、你可以使用光标上下键调出以前的命令。但以前我用过的一个MySQL旧版本不支持。我现在用的是mysql-3.23.27-beta-win。

二、显示命令

1、显示数据库列表：

show databases;

刚开始时才两个数据库：mysql和test。MySQL库很重要它里面有MYSQL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。

2、显示库中的数据表：

use mysql；／／打开库，学过FOXBASE的一定不会陌生吧

show tables;

3、显示数据表的结构：

describe 表名;

4、建库：

create database 库名;

5、建表：

use 库名；

create table 表名 (字段设定列表)；

6、删库和删表:

drop database 库名;

drop table 表名；

7、将表中记录清空：

delete from 表名;

8、显示表中的记录：

select * from 表名;

三、一个建库和建表以及插入数据的实例

drop database if exists school; //如果存在SCHOOL则删除

create database school; //建立库SCHOOL

use school; //打开库SCHOOL

create table teacher //建立表TEACHER

(

id int(3) auto_increment not null primary key,

name char(10) not null,

address varchar(50) default ’深圳’,

year date

); //建表结束

//以下为插入字段

insert into teacher values(’’,’glchengang’,’深圳一中’,’1976-10-10’);

insert into teacher values(’’,’jack’,’深圳一中’,’1975-12-23’);

注：在建表中（1）将ID设为长度为3的数字字段:int(3)并让它每个记录自动加一:auto_increment并不能为空:not null而且让他成为主字段primary key（2）将NAME设为长度为10的字符字段（3）将ADDRESS设为长度50的字符字段，而且缺省值为深圳。varchar和char有什么区别呢，只有等以后的文章再说了。（4）将YEAR设为日期字段。

如果你在MySQL提示符键入上面的命令也可以，但不方便调试。你可以将以上命令原样写入一个文本文件中假设为school.sql，然后复制到c:\\下，并在DOS状态进入目录\\mysql\\bin，然后键入以下命令：

mysql -uroot -p密码 < c:\\school.sql

如果成功，空出一行无任何显示；如有错误，会有提示。（以上命令已经调试，你只要将//的注释去掉即可使用）。

四、将文本数据转到数据库中

1、文本数据应符合的格式：字段数据之间用tab键隔开，null值用\\n来代替。

例：

3 rose 深圳二中 1976-10-10

4 mike 深圳一中 1975-12-23

2、数据传入命令 load data local infile \"文件名\" into table 表名。

注意：你最好将文件复制到\\mysql\\bin目录下，并且要先用use命令打表所在的库。

五、备份数据库：

1、mysqldump --opt school>school.bbb

mysqldump --opt school>school.bbb

（命令在DOS的\\mysql\\bin目录下执行）

注释:将数据库school备份到school.bbb文件，school.bbb是一个文本文件，文件名任取，打开看看你会有新发现。

后记：其实MySQL的对数据库的操作与其它的SQL类数据库大同小异，您最好找本将SQL的书看看。我在这里只介绍一些基本的，其实我也就只懂这些了，呵呵。最好的MYSQL教程还是“晏子“译的“MYSQL中文参考手册“不仅免费每个相关网站都有下载，而且它是最权威的。可惜不是象\"PHP4中文手册\"那样是chm的格式，在查找函数命令的时候不太方便。

2、修改登录密码

1) mysqladmin -u用户名 -p旧密码 password 新密码:

例：mysqladmin -u root password 21century

注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。

2)直接修改user表的root用户口令：

mysql> user mysql;

mysql> update user set pasword=password('21century') where user='root';

mysql> flush privileges;

注：flush privileges的意思是强制刷新内存授权表，否则用的还是缓冲中的口令。

3、测试密码是否修改成功:

1）不用密码登录:

[root@test1 local]# mysql

ERROR 1045: Access denied for user: 'root@localhost' (Using password: NO)

显示错误，说明密码已经修改。

2）用修改后的密码登录:

[root@test1 local]# mysql -u root -p

Enter password: (输入修改后的密码21century)

Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 177 to server version: 3.23.48

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

成功！

这是通过mysqladmin命令修改口令，也可通过修改库来更改口令。

4、启动和停止:

启动：Mysql从3.23.15版本开始作了改动，默认安装后服务要用MySQL用户来启动，不允许root用户启动。

如果非要用root用户来启动，必须加上--user=root参数(./safe_mysqld --user=root &)停止：mysqladmin -u root -p shutdown。

5、导出meeting数据库：

mysqldump -uroot -p21century meeting > db_meeting.sql

导人dbname数据库:

mysqldump -uroot -p21century dbname < xxx.sql

导入数据库还可用类似于oracle中@my_script.sql的方式一次执行大量sql语句，这在使用mysqldump不起作用时非常有用。

例：#./mysql -uroot -p < /home/xuys/db_meeting_2003.sql

(注：create database、use databasename、create table和insert into语句都可写在上面的脚步文件中)

6、给表改名:

RENAME TABLE ztemp TO zteMP4;

7、修改字段属性：

ALTER TABLE bbabase CHANGE news_id id VARCHAR(5) NOT NULL;

8、在表中的content后增加一字段：

ALTER TABLE bbabase ADD leave_time DATETIME NOT NULL AFTER

李春生 2011-01-21 11:17 发表评论

mysql安装

李春生 — Fri, 21 Jan 2011 03:16:00 GMT

shell> groupadd mysql
shell> useradd -g mysql mysql
shell> gunzip < mysql-VERSION.tar.gz | tar -xvf -
shell> cd mysql-VERSION
shell> ./configure --prefix=/usr/local/mysql
shell> make
shell> make install
shell> cp support-files/my-medium.cnf /etc/my.cnf
shell> cd /usr/local/mysql
shell> bin/mysql_install_db --user=mysql
shell> chown -R root .
shell> chown -R mysql var
shell> chgrp -R mysql .
shell> bin/mysqld_safe --user=mysql &

李春生 2011-01-21 11:16 发表评论

linux系统下jdk1.6安装

李春生 — Fri, 21 Jan 2011 03:14:00 GMT

1. 从网站上下载jdk1.6包(jdk-6u10-linux-i586-rpm.bin ),通过leapFTP上传到linux系统的/var/ftp/pub目录下

2.在linux中切换到 /var/ftp/pub目录下，修改jdk1.6的使用权限：#chmod u+x jdk-6u10-linux-i586-rpm.bin

3.解压并安装：#./ jdk-6u10-linux-i586-rpm.bin (默认安装在/usr/java中)

4.环境变量配置：

#vi /etc/profile

在该profile文件中添加：

JAVA_HOME=/usr/java/jdk1.6.0_10

JRE_HOME=/usr/java/jdk1.6.0_10/jre

PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin

CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib

export JAVA_HOME JRE_HOME PATH CLASSPATH

添加完毕保存退出

#source /etc/profile

#java -version

显示 java version "1.6.0_10" (jdk1.6安装成功)

卸载rpm版的jdk：

#rpm -qa|grep jdk

显示：jdk-1.6.0_10-fcs
卸载：#rpm -e --nodeps jdk-1.6.0_10-fcs

李春生 2011-01-21 11:14 发表评论

mysql slave,master配置

李春生 — Fri, 21 Jan 2011 03:09:00 GMT

一个完整的mysql读写分离环境包括以下几个部分：

应用程序client
database proxy
database集群
在本次实战中，应用程序client基于c3p0连接后端的database proxy。database proxy负责管理client实际访问database的路由策略，采用开源框架amoeba。database集群采用mysql的master-slave的replication方案。整个环境的结构图如下所示：

实战步骤与详解

一.搭建mysql的master-slave环境

1）分别在host1（10.20.147.110）和host2（10.20.147.111）上安装mysql（5.0.45），具体安装方法可见官方文档

2）配置master

首先编辑/etc/my.cnf，添加以下配置：

log-bin=mysql-bin #slave会基于此log-bin来做replication
server-id=1 #master的标示
binlog-do-db = amoeba_study #用于master-slave的具体数据库

然后添加专门用于replication的用户：

mysql> GRANT REPLICATION SLAVE ON *.* TO repl@10.20.147.111 IDENTIFIED BY '111111';

重启mysql，使得配置生效：

/etc/init.d/mysqld restart

最后查看master状态：

3）配置slave

首先编辑/etc/my.cnf，添加以下配置：

server-id=2 #slave的标示

配置生效后，配置与master的连接：

mysql> CHANGE MASTER TO
    -> MASTER_HOST='10.20.147.110',
    -> MASTER_USER='repl',
    -> MASTER_PASSWORD='111111',
    -> MASTER_LOG_FILE='mysql-bin.000003',
    -> MASTER_LOG_POS=161261;

其中MASTER_HOST是master机的ip，MASTER_USER和MASTER_PASSWORD就是我们刚才在master上添加的用户，MASTER_LOG_FILE和MASTER_LOG_POS对应与master status里的信息

最后启动slave：

mysql> start slave;

4）验证master-slave搭建生效

通过查看slave机的log（/var/log/mysqld.log）：

100703 10:51:42 [Note] Slave I/O thread: connected to master 'repl@10.20.147.110:3306', replication started in log 'mysql-bin.000003' at position 161261

如看到以上信息则证明搭建成功，如果有问题也可通过此log找原因

二.搭建database proxy

此次实战中database proxy采用amoeba ，它的相关信息可以查阅官方文档，不在此详述

1）安装amoeba

下载amoeba（1.2.0-GA）后解压到本地（D:\openSource\amoeba-mysql-1.2.0-GA），即完成安装

2）配置amoeba

先配置proxy连接和与各后端mysql服务器连接信息（D:\openSource\amoeba-mysql-1.2.0-GA\conf\amoeba.xml）：

    8066




    20


    30


    30


    128


    true


    root


    root

8066

20

30

30

128

true

root

root

以上是proxy提供给client的连接配置

            defaultManager


            3306


            10.20.147.110
            amoeba_study


            root








            200
            200
            10
            600000
            600000
            true
            true






            defaultManager


            3306


            10.20.147.111
            amoeba_study


            root








            200
            200
            10
            600000
            600000
            true
            true






   defaultManager


   3306


   10.20.147.110
   amoeba_study


   root








   200
   200
   10
   600000
   600000
   true
   true





   defaultManager


   3306


   10.20.147.111
   amoeba_study


   root








   200
   200
   10
   600000
   600000
   true
   true

以上是proxy与后端各mysql数据库服务器配置信息，具体配置见注释很明白了

最后配置读写分离策略：

    1500
    server1
    server1
    server2
    true

1500
server1
server1
server2
true

从以上配置不然发现，写操作路由到server1（master），读操作路由到server2（slave）

3）启动amoeba

在命令行里运行D:\openSource\amoeba-mysql-1.2.0-GA\amoeba.bat即可：

log4j:WARN log4j config load completed from file:D:\openSource\amoeba-mysql-1.2.0-GA\conf\log4j.xml
log4j:WARN ip access config load completed from file:D:\openSource\amoeba-mysql-1.2.0-GA/conf/access_list.conf
2010-07-03 09:55:33,821 INFO net.ServerableConnectionManager - Server listening on 0.0.0.0/0.0.0.0:8066.
三.client端调用与测试

1）编写client调用程序

具体程序细节就不详述了，只是一个最普通的基于mysql driver的jdbc的数据库操作程序

2）配置数据库连接

本client基于c3p0，具体数据源配置如下：

    destroy-method="close">

















destroy-method="close">

值得注意是，client端只需连到proxy，与实际的数据库没有任何关系，因此jdbcUrl、user、password配置都对应于amoeba暴露出来的配置信息

3）调用与测试

首先插入一条数据：insert into zone_by_id(id,name) values(20003,'name_20003')

通过查看master机上的日志/var/lib/mysql/mysql_log.log：

100703 11:58:42       1 Query       set names latin1
                      1 Query       SET NAMES latin1
                      1 Query       SET character_set_results = NULL
                      1 Query       SHOW VARIABLES
                      1 Query       SHOW COLLATION
                      1 Query       SET autocommit=1
                      1 Query       SET sql_mode='STRICT_TRANS_TABLES'
                      1 Query       SHOW VARIABLES LIKE 'tx_isolation'
                      1 Query       SHOW FULL TABLES FROM `amoeba_study` LIKE 'PROBABLYNOT'
                      1 Prepare     [1] insert into zone_by_id(id,name) values(?,?)
                      1 Prepare     [2] insert into zone_by_id(id,name) values(?,?)
                      1 Execute     [2] insert into zone_by_id(id,name) values(20003,'name_20003')

得知写操作发生在master机上

通过查看slave机上的日志/var/lib/mysql/mysql_log.log：

100703 11:58:42 2 Query insert into zone_by_id(id,name) values(20003,'name_20003')

得知slave同步执行了这条语句

然后查一条数据：select t.name from zone_by_id t where t.id = 20003

通过查看slave机上的日志/var/lib/mysql/mysql_log.log：

100703 12:02:00      33 Query       set names latin1
                     33 Prepare     [1] select t.name from zone_by_id t where t.id = ?
                     33 Prepare     [2] select t.name from zone_by_id t where t.id = ?
                     33 Execute     [2] select t.name from zone_by_id t where t.id = 20003

得知读操作发生在slave机上

并且通过查看slave机上的日志/var/lib/mysql/mysql_log.log发现这条语句没在master上执行

通过以上验证得知简单的master-slave搭建和实战得以生效

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/cutesource/archive/2010/07/03/5710645.aspx

李春生 2011-01-21 11:09 发表评论

实现验证码

李春生 — Tue, 16 Dec 2008 08:17:00 GMT

以下类产生4位验证码

public class ImageTool{

private static Random random = new Random();

public ImageTool() {
}

public static Color getRandColor(int fc,int bc){//给定范围获得随机颜色
    if(fc>255) fc=255;
    if(bc>255) bc=255;
    int r=fc+random.nextInt(bc-fc);
    int g=fc+random.nextInt(bc-fc);
    int b=fc+random.nextInt(bc-fc);
    return new Color(r,g,b);
}

public static void outputImage(HttpSession session, HttpServletResponse response) throws IOException{

BufferedImage image = new BufferedImage(60, 20, BufferedImage.TYPE_INT_RGB);
Graphics g = image.getGraphics();

g.setColor(getRandColor(200, 250));
g.fillRect(0, 0, 60, 20);

g.setFont(new Font("Times New Roman",Font.PLAIN,18));

    g.setColor(getRandColor(160, 200));
    for (int i=0;i<155;i++) {
      int x = random.nextInt(60);
      int y = random.nextInt(20);
      int xl = random.nextInt(12);
      int yl = random.nextInt(12);
      g.drawLine(x,y,x+xl,y+yl);
    }

g.dispose();
OutputStream out=response.getOutputStream();

    response.reset();
    ImageIO.write(image, "jpg", out);
    out.close();
}

public static void imagePut(HttpSession session,OutputStream out,int pWidth,int pHeight,int pSize) throws IOException{

BufferedImage image = new BufferedImage(pWidth, pHeight, BufferedImage.TYPE_INT_RGB);
Graphics g = image.getGraphics();

g.setColor(getRandColor(200, 250));
g.fillRect(0, 0, pWidth, pHeight);

g.setFont(new Font("Times New Roman",Font.PLAIN,pSize));

    g.setColor(getRandColor(160, 200));
    for (int i=0;i<18;i++) {
      int x = random.nextInt(60);
      int y = random.nextInt(20);
      int xl = random.nextInt(12);
      int yl = random.nextInt(12);
      g.drawLine(x,y,x+xl,y+yl);
    }

    StringBuffer randCode = new StringBuffer();
    for (int i=0;i<4;i++){
      String temp = String.valueOf(random.nextInt(10));
      randCode.append(temp);
      g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
      g.drawString(temp,13*i+6,16);
    }
    g.dispose();
    ImageIO.write(image, "jpg", out);
    session.setAttribute("randCode", randCode.toString());
//    System.out.println("sessionID："+session.toString()+"；产生的验证码："+session.getAttribute("randCode"));

}

public static void imagePutOneColor(HttpSession session,OutputStream out,int pWidth,int pHeight,int pSize) throws IOException{

BufferedImage image = new BufferedImage(pWidth, pHeight, BufferedImage.TYPE_INT_RGB);
Graphics g = image.getGraphics();

g.setColor(new Color(255,255,255));
g.fillRect(0, 0, 60, 20);

g.setFont(new Font("Times New Roman",Font.TRUETYPE_FONT,pSize));

    g.setColor(getRandColor(200, 250));
    for (int i=0;i<18;i++) {
      int x = random.nextInt(60);
      int y = random.nextInt(20);
      int xl = random.nextInt(12);
      int yl = random.nextInt(12);
      g.drawLine(x,y,x+xl,y+yl);
    }

    StringBuffer randCode = new StringBuffer();
    for (int i=0;i<4;i++){
      String temp = String.valueOf(random.nextInt(10));
      randCode.append(temp);
      g.setColor(new Color(0,0,0));
      g.drawString(temp,13*i+6,16);
    }
    session.setAttribute("randCode", randCode.toString());

g.dispose();
ImageIO.write(image, "jpg", out);
}

public static void outputImage(String sessionName, HttpSession session, HttpServletResponse response) throws IOException{

BufferedImage image = new BufferedImage(60, 20, BufferedImage.TYPE_INT_RGB);
Graphics g = image.getGraphics();

g.setColor(getRandColor(200, 250));
g.fillRect(0, 0, 60, 20);

g.setFont(new Font("Times New Roman",Font.PLAIN,18));

    StringBuffer randCode = new StringBuffer();
    for (int i=0;i<4;i++){
      String temp = String.valueOf(random.nextInt(10));
      randCode.append(temp);
      g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
      g.drawString(temp,13*i+6,16);
    }
    session.setAttribute(sessionName, randCode.toString());
    g.dispose();
    response.reset();
    OutputStream out=response.getOutputStream();
    ImageIO.write(image, "JPEG", out);

out.flush();
out.close();
}
}

李春生 2008-12-16 16:17 发表评论

spring cron表达式

李春生 — Tue, 16 Dec 2008 08:06:00 GMT

Cron表达式是一个字符串，字符串以5或6个空格隔开，分开工6或7个域，每一个域代表一个含义,Cron有如下两种语法
格式：
Seconds Minutes Hours DayofMonth Month DayofWeek Year 或
Seconds Minutes Hours DayofMonth Month DayofWeek
每一个域可出现的字符如下：

代码
Seconds:可出现,- * / 四个字符，有效范围为0-59的整数
Minutes:可出现,- * / 四个字符，有效范围为0-59的整数
Hours:可出现,- * / 四个字符，有效范围为0-23的整数
DayofMonth:可出现,- * / ? L W C八个字符，有效范围为0-31的整数
Month:可出现,- * / 四个字符，有效范围为1-12的整数或JAN-DEc
DayofWeek:可出现,- * / ? L C #四个字符，有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天，2表示星期一，依次类推
Year:可出现,- * / 四个字符，有效范围为1970-2099年

每一个域都使用数字，但还可以出现如下特殊字符，它们的含义是：

代码
(1)*：表示匹配该域的任意值，假如在Minutes域使用*,即表示每分钟都会触发事件。

(2)?:只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?,其中最后一位只能用？，而不能使用*，如果使用*表示不管星期几都会触发，实际上并不是这样。

(3)-:表示范围，例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次

(4)/：表示起始时间开始触发，然后每隔固定时间触发一次，例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.

(5),:表示列出枚举值值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。

(6)L:表示最后，只能出现在DayofWeek和DayofMonth域，如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。

(7)W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份

(8)LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。

(9)#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。
举几个例子:

代码
0 0 2 1 * ? * 表示在每月的1日的凌晨2点调度任务
0 15 10 ? * MON-FRI 表示周一到周五每天上午10：15执行作业
0 15 10 ? 6L 2002-2006 表示200-2006年的每个月的最后一个星期五上午10:15执行作业
91linux

一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。

按顺序依次为
秒（0~59）
分钟（0~59）

小时（0~23）

天（月）（0~31，但是你需要考虑你月的天数）

月（0~11）

天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）

7.年份（1970－2099）

其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.

0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

有些子表达式能包含一些范围或列表

例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

“*”字符代表所有可能的值

因此，“*”在子表达式（月）里表示每个月的含义，“*”在子表达式（天（星期））表示星期的每一天

“/”字符用来指定数值的增量

例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟

在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值

当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写

但是它在两个子表达式里的含义是不同的。

在天（月）子表达式中，“L”表示一个月的最后一天

在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

如果在“L”前有具体的内容，它就具有其他的含义了

例如：“6L”表示这个月的倒数第６天，“ＦＲＩＬ”表示这个月的最一个星期五

注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

字段   允许值   允许的特殊字符
秒    0-59    , - * /
分    0-59    , - * /
小时    0-23    , - * /
日期    1-31    , - * ? / L W C
月份    1-12 或者 JAN-DEC    , - * /
星期    1-7 或者 SUN-SAT    , - * ? / L C #
年（可选）    留空, 1970-2099    , - * /

李春生 2008-12-16 16:06 发表评论

java实现ip查询

李春生 — Tue, 16 Dec 2008 07:56:00 GMT

用java实现对纯真IP数据库的查询，首先到网上下载QQwry.da文件，读取代码如下：
1.IP记录实体类

package com.guess.tools;

/** *
* 一条IP范围记录，不仅包括国家和区域，也包括起始IP和结束IP *

*
* @author swallow */
public class IPEntry {
    public String beginIp;
    public String endIp;
    public String country;
    public String area;

    /** *//**
     * 构造函数
     */

public IPEntry() {
        beginIp = endIp = country = area = "";
    }

    public String toString(){
       return        this.area+" "+this.country+"IP范围:"+this.beginIp+"-"+this.endIp;
    }
   }
2.读取QQwry.dat文件类

package com.guess.tools;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

/** *//**
* * 用来读取QQwry.dat文件，以根据ip获得好友位置，QQwry.dat的格式是
* 一. 文件头，共8字节
*        1. 第一个起始IP的绝对偏移， 4字节
*     2. 最后一个起始IP的绝对偏移， 4字节
* 二. "结束地址/国家/区域"记录区
*     四字节ip地址后跟的每一条记录分成两个部分
*     1. 国家记录
*     2. 地区记录
*     但是地区记录是不一定有的。而且国家记录和地区记录都有两种形式
*     1. 以0结束的字符串
*     2. 4个字节，一个字节可能为0x1或0x2
*           a. 为0x1时，表示在绝对偏移后还跟着一个区域的记录，注意是绝对偏移之后，而不是这四个字节之后
*        b. 为0x2时，表示在绝对偏移后没有区域记录
*        不管为0x1还是0x2，后三个字节都是实际国家名的文件内绝对偏移
*           如果是地区记录，0x1和0x2的含义不明，但是如果出现这两个字节，也肯定是跟着3个字节偏移，如果不是
*        则为0结尾字符串
* 三. "起始地址/结束地址偏移"记录区
*     1. 每条记录7字节，按照起始地址从小到大排列
*        a. 起始IP地址，4字节
*        b. 结束ip地址的绝对偏移，3字节
*
* 注意，这个文件里的ip地址和所有的偏移量均采用little-endian格式，而java是采用
* big-endian格式的，要注意转换
*
*
* @author 马若劼
*/
public class IPSeeker {
    /** *//**
     *      * 用来封装ip相关信息，目前只有两个字段，ip所在的国家和地区
     *
     *
     * @author swallow     */
    private class IPLocation {
        public String country;
        public String area;

        public IPLocation() {
            country = area = "";
        }

        public IPLocation getCopy() {
            IPLocation ret = new IPLocation();
            ret.country = country;
            ret.area = area;
            return ret;
        }
    }

private static final String IP_FILE = IPSeeker.class.getResource("/QQWry.DAT").toString().substring(5);

    // 一些固定常量，比如记录长度等等
    private static final int IP_RECORD_LENGTH = 7;
    private static final byte AREA_FOLLOWED = 0x01;
    private static final byte NO_AREA = 0x2;

     // 用来做为cache，查询一个ip时首先查看cache，以减少不必要的重复查找
    private Hashtable ipCache;
    // 随机文件访问类
    private RandomAccessFile ipFile;
    // 内存映射文件
    private MappedByteBuffer mbb;
    // 单一模式实例
    private static IPSeeker instance = new IPSeeker();
    // 起始地区的开始和结束的绝对偏移
    private long ipBegin, ipEnd;
    // 为提高效率而采用的临时变量
    private IPLocation loc;
    private byte[] buf;
    private byte[] b4;
    private byte[] b3;

    /** *//**
     * 私有构造函数
     */
    private IPSeeker() {
        ipCache = new Hashtable();
        loc = new IPLocation();
        buf = new byte[100];
        b4 = new byte[4];
        b3 = new byte[3];
        try {
            ipFile = new RandomAccessFile(IP_FILE, "r");
        } catch (FileNotFoundException e) {
                        System.out.println(IPSeeker.class.getResource("/QQWry.DAT").toString());
                        System.out.println(IP_FILE);
            System.out.println("IP地址信息文件没有找到，IP显示功能将无法使用");
            ipFile = null;

        }
        // 如果打开文件成功，读取文件头信息
        if(ipFile != null) {
            try {
                ipBegin = readLong4(0);
                ipEnd = readLong4(4);
                if(ipBegin == -1 || ipEnd == -1) {
                    ipFile.close();
                    ipFile = null;
                }
            } catch (IOException e) {
                System.out.println("IP地址信息文件格式有错误，IP显示功能将无法使用");
                ipFile = null;
            }
        }
    }

    /** *//**
     * @return 单一实例
     */
    public static IPSeeker getInstance() {
        return instance;
    }

    /** *//**
     * 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录
     * @param s 地点子串
     * @return 包含IPEntry类型的List
     */
    public List getIPEntriesDebug(String s) {
        List ret = new ArrayList();
        long endOffset = ipEnd + 4;
        for(long offset = ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
            // 读取结束IP偏移
            long temp = readLong3(offset);
            // 如果temp不等于-1，读取IP的地点信息
            if(temp != -1) {
                IPLocation loc = getIPLocation(temp);
                // 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
                if(loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
                    IPEntry entry = new IPEntry();
                    entry.country = loc.country;
                    entry.area = loc.area;
                    // 得到起始IP
                    readIP(offset - 4, b4);
                    entry.beginIp = Utils.getIpStringFromBytes(b4);
                    // 得到结束IP
                    readIP(temp, b4);
                    entry.endIp = Utils.getIpStringFromBytes(b4);
                    // 添加该记录
                    ret.add(entry);
                }
            }
        }
        return ret;
    }

    /** *//**
     * 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录
     * @param s 地点子串
     * @return 包含IPEntry类型的List
     */
    public List getIPEntries(String s) {
        List ret = new ArrayList();
        try {
            // 映射IP信息文件到内存中
            if(mbb == null) {
                FileChannel fc = ipFile.getChannel();
                mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, ipFile.length());
                mbb.order(ByteOrder.LITTLE_ENDIAN);
            }

            int endOffset = (int)ipEnd;
            for(int offset = (int)ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
                int temp = readInt3(offset);
                if(temp != -1) {
                    IPLocation loc = getIPLocation(temp);
                    // 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
                    if(loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
                        IPEntry entry = new IPEntry();
                        entry.country = loc.country;
                        entry.area = loc.area;
                        // 得到起始IP
                        readIP(offset - 4, b4);
                        entry.beginIp = Utils.getIpStringFromBytes(b4);
                        // 得到结束IP
                        readIP(temp, b4);
                        entry.endIp = Utils.getIpStringFromBytes(b4);
                        // 添加该记录
                        ret.add(entry);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return ret;
    }

    /** *//**
     * 从内存映射文件的offset位置开始的3个字节读取一个int
     * @param offset
     * @return
     */
    private int readInt3(int offset) {
        mbb.position(offset);
        return mbb.getInt() & 0x00FFFFFF;
    }

    /** *//**
     * 从内存映射文件的当前位置开始的3个字节读取一个int
     * @return
     */
    private int readInt3() {
        return mbb.getInt() & 0x00FFFFFF;
    }

    /** *//**
     * 根据IP得到国家名
     * @param ip ip的字节数组形式
     * @return 国家名字符串
     */
    public String getCountry(byte[] ip) {
        // 检查ip地址文件是否正常
        if(ipFile == null) return "错误的IP数据库文件";
        // 保存ip，转换ip字节数组为字符串形式
        String ipStr = Utils.getIpStringFromBytes(ip);
        // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
        if(ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation)ipCache.get(ipStr);
            return loc.country;
        } else {
            IPLocation loc = getIPLocation(ip);
            ipCache.put(ipStr, loc.getCopy());
            return loc.country;
        }
    }

    /** *//**
     * 根据IP得到国家名
     * @param ip IP的字符串形式
     * @return 国家名字符串
     */
    public String getCountry(String ip) {
        return getCountry(Utils.getIpByteArrayFromString(ip));
    }

    /** *//**
     * 根据IP得到地区名
     * @param ip ip的字节数组形式
     * @return 地区名字符串
     */
    public String getArea(byte[] ip) {
        // 检查ip地址文件是否正常
        if(ipFile == null) return "错误的IP数据库文件";
        // 保存ip，转换ip字节数组为字符串形式
        String ipStr = Utils.getIpStringFromBytes(ip);
        // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
        if(ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation)ipCache.get(ipStr);
            return loc.area;
        } else {
            IPLocation loc = getIPLocation(ip);
            ipCache.put(ipStr, loc.getCopy());
            return loc.area;
        }
    }

    /** *//**
     * 根据IP得到地区名
     * @param ip IP的字符串形式
     * @return 地区名字符串
     */
    public String getArea(String ip) {
        return getArea(Utils.getIpByteArrayFromString(ip));
    }

    /** *//**
     * 根据ip搜索ip信息文件，得到IPLocation结构，所搜索的ip参数从类成员ip中得到
     * @param ip 要查询的IP
     * @return IPLocation结构
     */
    private IPLocation getIPLocation(byte[] ip) {
        IPLocation info = null;
        long offset = locateIP(ip);
        if(offset != -1)
            info = getIPLocation(offset);
        if(info == null) {
            info = new IPLocation();
            info.country = "未知国家";
            info.area = "未知地区";
        }
        return info;
    }

    /** *//**
     * 从offset位置读取4个字节为一个long，因为java为big-endian格式，所以没办法
     * 用了这么一个函数来做转换
     * @param offset
     * @return 读取的long值，返回-1表示读取文件失败
     */
    private long readLong4(long offset) {
        long ret = 0;
        try {
            ipFile.seek(offset);
            ret |= (ipFile.readByte() & 0xFF);
            ret |= ((ipFile.readByte() << 8) & 0xFF00);
            ret |= ((ipFile.readByte() << 16) & 0xFF0000);
            ret |= ((ipFile.readByte() << 24) & 0xFF000000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /** *//**
     * 从offset位置读取3个字节为一个long，因为java为big-endian格式，所以没办法
     * 用了这么一个函数来做转换
     * @param offset
     * @return 读取的long值，返回-1表示读取文件失败
     */
    private long readLong3(long offset) {
        long ret = 0;
        try {
            ipFile.seek(offset);
            ipFile.readFully(b3);
            ret |= (b3[0] & 0xFF);
            ret |= ((b3[1] << 8) & 0xFF00);
            ret |= ((b3[2] << 16) & 0xFF0000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /** *//**
     * 从当前位置读取3个字节转换成long
     * @return
     */
    private long readLong3() {
        long ret = 0;
        try {
            ipFile.readFully(b3);
            ret |= (b3[0] & 0xFF);
            ret |= ((b3[1] << 8) & 0xFF00);
            ret |= ((b3[2] << 16) & 0xFF0000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /** *//**
     * 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
     * 文件中是little-endian形式，将会进行转换
     * @param offset
     * @param ip
     */
    private void readIP(long offset, byte[] ip) {
        try {
            ipFile.seek(offset);
            ipFile.readFully(ip);
            byte temp = ip[0];
            ip[0] = ip[3];
            ip[3] = temp;
            temp = ip[1];
            ip[1] = ip[2];
            ip[2] = temp;
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    /** *//**
     * 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
     * 文件中是little-endian形式，将会进行转换
     * @param offset
     * @param ip
     */
    private void readIP(int offset, byte[] ip) {
        mbb.position(offset);
        mbb.get(ip);
        byte temp = ip[0];
        ip[0] = ip[3];
        ip[3] = temp;
        temp = ip[1];
        ip[1] = ip[2];
        ip[2] = temp;
    }

    /** *//**
     * 把类成员ip和beginIp比较，注意这个beginIp是big-endian的
     * @param ip 要查询的IP
     * @param beginIp 和被查询IP相比较的IP
     * @return 相等返回0，ip大于beginIp则返回1，小于返回-1。
     */
    private int compareIP(byte[] ip, byte[] beginIp) {
        for(int i = 0; i < 4; i++) {
            int r = compareByte(ip[i], beginIp[i]);
            if(r != 0)
                return r;
        }
        return 0;
    }

    /** *//**
     * 把两个byte当作无符号数进行比较
     * @param b1
     * @param b2
     * @return 若b1大于b2则返回1，相等返回0，小于返回-1
     */
    private int compareByte(byte b1, byte b2) {
        if((b1 & 0xFF) > (b2 & 0xFF)) // 比较是否大于
            return 1;
        else if((b1 ^ b2) == 0)// 判断是否相等
            return 0;
        else
            return -1;
    }

    /** *//**
     * 这个方法将根据ip的内容，定位到包含这个ip国家地区的记录处，返回一个绝对偏移
     * 方法使用二分法查找。
     * @param ip 要查询的IP
     * @return 如果找到了，返回结束IP的偏移，如果没有找到，返回-1
     */
    private long locateIP(byte[] ip) {
        long m = 0;
        int r;
        // 比较第一个ip项
        readIP(ipBegin, b4);
        r = compareIP(ip, b4);
        if(r == 0) return ipBegin;
        else if(r < 0) return -1;
        // 开始二分搜索
        for(long i = ipBegin, j = ipEnd; i < j; ) {
            m = getMiddleOffset(i, j);
            readIP(m, b4);
            r = compareIP(ip, b4);
            // log.debug(Utils.getIpStringFromBytes(b));
            if(r > 0)
                i = m;
            else if(r < 0) {
                if(m == j) {
                    j -= IP_RECORD_LENGTH;
                    m = j;
                } else
                    j = m;
            } else
                return readLong3(m + 4);
        }
        // 如果循环结束了，那么i和j必定是相等的，这个记录为最可能的记录，但是并非
        //     肯定就是，还要检查一下，如果是，就返回结束地址区的绝对偏移
        m = readLong3(m + 4);
        readIP(m, b4);
        r = compareIP(ip, b4);
        if(r <= 0) return m;
        else return -1;
    }

    /** *//**
     * 得到begin偏移和end偏移中间位置记录的偏移
     * @param begin
     * @param end
     * @return
     */
    private long getMiddleOffset(long begin, long end) {
        long records = (end - begin) / IP_RECORD_LENGTH;
        records >>= 1;
        if(records == 0) records = 1;
        return begin + records * IP_RECORD_LENGTH;
    }

    /** *//**
     * 给定一个ip国家地区记录的偏移，返回一个IPLocation结构
     * @param offset
     * @return
     */
    private IPLocation getIPLocation(long offset) {
        try {
            // 跳过4字节ip
            ipFile.seek(offset + 4);
            // 读取第一个字节判断是否标志字节
            byte b = ipFile.readByte();
            if(b == AREA_FOLLOWED) {
                // 读取国家偏移
                long countryOffset = readLong3();
                // 跳转至偏移处
                ipFile.seek(countryOffset);
                // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
                b = ipFile.readByte();
                if(b == NO_AREA) {
                    loc.country = readString(readLong3());
                    ipFile.seek(countryOffset + 4);
                } else
                    loc.country = readString(countryOffset);
                // 读取地区标志
                loc.area = readArea(ipFile.getFilePointer());
            } else if(b == NO_AREA) {
                loc.country = readString(readLong3());
                loc.area = readArea(offset + 8);
            } else {
                loc.country = readString(ipFile.getFilePointer() - 1);
                loc.area = readArea(ipFile.getFilePointer());
            }
            return loc;
        } catch (IOException e) {
            return null;
        }
    }

    /** *//**
     * @param offset
     * @return
     */
    private IPLocation getIPLocation(int offset) {
        // 跳过4字节ip
        mbb.position(offset + 4);
        // 读取第一个字节判断是否标志字节
        byte b = mbb.get();
        if(b == AREA_FOLLOWED) {
            // 读取国家偏移
            int countryOffset = readInt3();
            // 跳转至偏移处
            mbb.position(countryOffset);
            // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
            b = mbb.get();
            if(b == NO_AREA) {
                loc.country = readString(readInt3());
                mbb.position(countryOffset + 4);
            } else
                loc.country = readString(countryOffset);
            // 读取地区标志
            loc.area = readArea(mbb.position());
        } else if(b == NO_AREA) {
            loc.country = readString(readInt3());
            loc.area = readArea(offset + 8);
        } else {
            loc.country = readString(mbb.position() - 1);
            loc.area = readArea(mbb.position());
        }
        return loc;
    }

    /** *//**
     * 从offset偏移开始解析后面的字节，读出一个地区名
     * @param offset
     * @return 地区名字符串
     * @throws IOException
     */
    private String readArea(long offset) throws IOException {
        ipFile.seek(offset);
        byte b = ipFile.readByte();
        if(b == 0x01 || b == 0x02) {
            long areaOffset = readLong3(offset + 1);
            if(areaOffset == 0)
                return "未知地区";
            else
                return readString(areaOffset);
        } else
            return readString(offset);
    }

    /** *//**
     * @param offset
     * @return
     */
    private String readArea(int offset) {
        mbb.position(offset);
        byte b = mbb.get();
        if(b == 0x01 || b == 0x02) {
            int areaOffset = readInt3();
            if(areaOffset == 0)
                return "未知地区";
            else
                return readString(areaOffset);
        } else
            return readString(offset);
    }

    /** *//**
     * 从offset偏移处读取一个以0结束的字符串
     * @param offset
     * @return 读取的字符串，出错返回空字符串
     */
    private String readString(long offset) {
        try {
            ipFile.seek(offset);
            int i;
            for(i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile.readByte());
            if(i != 0)
                return Utils.getString(buf, 0, i, "GBK");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    /** *//**
     * 从内存映射文件的offset位置得到一个0结尾字符串
     * @param offset
     * @return
     */
    private String readString(int offset) {
        try {
            mbb.position(offset);
            int i;
            for(i = 0, buf[i] = mbb.get(); buf[i] != 0; buf[++i] = mbb.get());
            if(i != 0)
                return Utils.getString(buf, 0, i, "GBK");
        } catch (IllegalArgumentException e){
         System.out.println(e.getMessage());
        }
        return "";
    }

    public String getAddress(String ip){
        String country = getCountry(ip).equals(" CZ88.NET")?"":getCountry(ip);
        String area = getArea(ip).equals(" CZ88.NET")?"":getArea(ip);
        String address = country+" "+area;
        return address.trim();
    }
    public static void main(String args[]) {
    List list=IPSeeker.getInstance().getIPEntriesDebug("浙江省杭州市");



    }
}

李春生 2008-12-16 15:56 发表评论