JAVA网页设计依据IP找地点的java完成

手机用到的是用j2me所编出来的小程序。依据IP找地点的java完成,能将        分开的ip,地点格局(肇端IP        停止IP        国度        区域
)转化为升序的二进制格局,经由过程二分查找能在50-150ms内找到对应IP的地点信息.
原始数据可用IPLook天生.代码:

IPTool.java
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
/*
*创立日期2004-10-23
*
*/
packagestarfire.proxy.ip;

importjava.io.BufferedReader;
importjava.io.DataOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.RandomAccessFile;
importjava.net.InetAddress;
importjava.net.UnknownHostException;
importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.Comparator;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.StringTokenizer;

/**
*4|4|4|4|4#总记录数|ip偏移量|索引偏移量|数据偏移量
*(4|4|2|2)*#肇端IP|停止IP|国度索引|地区索引
*(2|4)*#2位索引,4位偏移量(指向对应country|local入手下手地位)(countryNULL|localNULL)*
*
*@authorstarfire
*
*/
publicclassIPTool{
privateStringdataPath;

privateRandomAccessFileraf;

privateIPFileipfile;

privatebyte[]buffer=newbyte[40];

privateIPInfominInfo=newIPInfo();

privateIPInfomaxInfo=newIPInfo();

publicstaticintstr2Ip(Stringip)throwsUnknownHostException{
InetAddressaddress=InetAddress.getByName(ip);
byte[]bytes=address.getAddress();
inta,b,c,d;
a=byte2int(bytes[0]);
b=byte2int(bytes[1]);
c=byte2int(bytes[2]);
d=byte2int(bytes[3]);
intresult=(a<<24)|(b<<16)|(c<<8)|d;
returnresult;
}

publicstaticintbyte2int(byteb){
intl=b&0x07f;
if(b<0){
l|=0x80;
}
returnl;
}

publicstaticvoidformat(StringdataPath,StringtargetPath)
throwsIOException{
longtime=System.currentTimeMillis();
BufferedReaderin=newBufferedReader(newInputStreamReader(
newFileInputStream(dataPath)));
FileOutputStreamfos=newFileOutputStream(targetPath);
DataOutputStreamout=newDataOutputStream(fos);
Stringline;
ArrayListipList=newArrayList(150000);
HashMapmap=newHashMap(65535);
ArrayListdataList=newArrayList(65535);
Iteratoriterator=null;
while((line=in.readLine())!=null){
StringTokenizertoken=newStringTokenizer(line,"        ");
Stringstart;
Stringend;
Stringcountry;
Stringlocal;
if(token.countTokens()==4){
start=token.nextToken();
end=token.nextToken();
country=token.nextToken().trim();
local=token.nextToken();
if(local.startsWith("/")){
local=local.substring(1);
}
local=local.trim();
try{
IPOriginInfoinfo=newIPOriginInfo();
info.startIP=str2Ip(start);
info.endIP=str2Ip(end);
info.country=country;
info.local=local;
ipList.add(info);
Objectobj=map.put(country,newInteger(map.size()));
if(obj!=null){
map.put(country,obj);
}
else{
dataList.add(country);
}
obj=map.put(local,newInteger(map.size()));
if(obj!=null){
map.put(local,obj);
}
else{
dataList.add(local);
}
}catch(UnknownHostExceptione){
continue;
}
}
}

IPFileipfile=newIPFile();
ipfile.totalRecords=ipList.size();
ipfile.ipOffset=IPFile.HEADER_SIZE;
ipfile.indexOffset=ipfile.ipOffset+ipList.size()
*IPFile.IP_INFO_SIZE;
ipfile.dataOffset=ipfile.indexOffset+map.size()*IPFile.INDEX_SIZE;

System.out.println("totalrecords:"+ipfile.totalRecords);
System.out.println("ipoffset:"+ipfile.ipOffset);
System.out.println("indexoffset:"+ipfile.indexOffset);
System.out.println("dataoffset:"+ipfile.dataOffset);
System.out.println("datasize:"+map.size());
//System.out.println("totalsize:"+total);

out.writeInt(ipfile.magic);
out.writeInt(ipfile.totalRecords);
out.writeInt(ipfile.ipOffset);
out.writeInt(ipfile.indexOffset);
out.writeInt(ipfile.dataOffset);
out.flush();

//排序
Collections.sort(ipList,newComparator(){

publicintcompare(Objecto1,Objecto2){
IPOriginInfoinfo1=(IPOriginInfo)o1;
IPOriginInfoinfo2=(IPOriginInfo)o2;
longstart=int2long(info1.startIP);
longend=int2long(info2.startIP);
return(int)(start-end);
}

});
//写ip信息
iterator=ipList.iterator();
while(iterator.hasNext()){
IPOriginInfoinfo=(IPOriginInfo)iterator.next();
out.writeInt(info.startIP);
out.writeInt(info.endIP);
shorts=((Integer)map.get(info.country)).shortValue();
out.writeShort(s);
s=((Integer)map.get(info.local)).shortValue();
out.writeShort(s);
}
out.flush();

//写索引信息
intposition=ipfile.dataOffset;
intnum=0;
iterator=dataList.iterator();
while(iterator.hasNext()){
Stringvalue=(String)iterator.next();
out.writeShort(num++);
out.writeInt(position);
if(position>2729877){
System.err.println("error:"+position);
}
position+=value.getBytes().length+1;
}
out.flush();

//写country|local数据
//iterator=sort.iterator();
intsize=dataList.size();
for(inti=0;i<size;i++){
Stringvalue=(String)dataList.get(i);
out.write(value.getBytes());
out.write((byte)0);
}
out.flush();

in.close();
out.close();
System.out.println("used"+(System.currentTimeMillis()-time)/1000
+"seconds");
}

publicIPTool(StringdataPath)throwsIOException{
this.dataPath=dataPath;
this.ipfile=newIPFile();
load(dataPath);
}

voidload(StringdataPath)throwsIOException{
Filef=newFile(dataPath);
raf=newRandomAccessFile(f,"r");
intmagic=raf.readInt();
if(magic!=IPFile.MAGIC){
thrownewIOException("badformat,magicnumbernotmatch");
}
ipfile.totalRecords=raf.readInt();
ipfile.ipOffset=raf.readInt();
ipfile.indexOffset=raf.readInt();
ipfile.dataOffset=raf.readInt();
ipfile.dataCount=(ipfile.dataOffset-ipfile.indexOffset)
/IPFile.INDEX_SIZE;
if(raf.length()<ipfile.dataOffset){
thrownewIOException("badformat,lengthnotmatch");
}
ipfile.ipCount=(ipfile.indexOffset-ipfile.ipOffset)
/IPFile.IP_INFO_SIZE;
ipfile.minIP=int2long(raf.readInt());
raf.seek(ipfile.indexOffset-IPFile.IP_INFO_SIZE);
ipfile.maxIP=int2long(raf.readInt());
//System.out.println(ipfile.ipCount);
//fillInfo(0,minInfo);
//fillInfo(ipfile.ipCount-1,maxInfo);
}

privatevoidfillInfo(intpos,IPInfoinfo)throwsIOException{
raf.seek(ipfile.ipOffset+pos*IPFile.IP_INFO_SIZE+8);
intci=short2int(raf.readShort());
intli=short2int(raf.readShort());
raf.seek(ipfile.indexOffset+ci*IPFile.INDEX_SIZE+2);
ci=raf.readInt();
raf.seek(ipfile.indexOffset+li*IPFile.INDEX_SIZE+2);
li=raf.readInt();
longcl=int2long(ci);
longll=int2long(li);
//System.out.println("ci="+cl+"li="+ll);
raf.seek(cl);
intret=raf.read(buffer);
inti=0;
for(;i<ret;i++){
if(buffer[i]==0){
break;
}
}
info.setCountry(newString(buffer,0,i));
raf.seek(ll);
ret=raf.read(buffer);
for(i=0;i<ret;i++){
if(buffer[i]==0){
break;
}
}
info.setLocal(newString(buffer,0,i));
//System.out.println(ll+"length="+raf.length());
}

publicsynchronizedIPInfofind(Stringip){
IPInfoinfo=newIPInfo();
info.setIp(ip);
try{
//longtime=System.currentTimeMillis();
longipNum=ip2long(ip);
intpos=-1;
if(ipNum==ipfile.minIP){
pos=0;
}elseif(ipNum==ipfile.maxIP){
pos=ipfile.ipCount-1;
}else{

pos=find(0,ipfile.ipCount-1,ipNum);
}
if(pos!=-1){
fillInfo(pos,info);
}
//System.out.println("time="+(System.currentTimeMillis()-time));
}catch(UnknownHostExceptione){

}catch(IOExceptione){
e.printStackTrace();
}
returninfo;
}

publicintfind(intstart,intend,longtarget)throwsIOException{
if(start>=end){
return-1;
}
intmiddle=(end+start)/2;
raf.seek(ipfile.ipOffset+middle*IPFile.IP_INFO_SIZE);
longi=int2long(raf.readInt());
longj=int2long(raf.readInt());
if(target>=i&&target<=j){
returnmiddle;
}
if(target<i){
end=middle;
}else{
start=middle;
}
returnfind(start,end,target);
}

publicstaticlongip2long(Stringip)throwsUnknownHostException{
intipNum=str2Ip(ip);
returnint2long(ipNum);
}

publicstaticlongint2long(inti){
longl=i&0x7fffffffL;
if(i<0){
l|=0x080000000L;
}
returnl;
}

publicstaticintshort2int(shorts){
inti=s&0x7fff;
if(s<0){
s|=0x08000;
}
returns;
}

protectedvoidfinalize(){
if(raf!=null){
try{
raf.close();
}catch(IOExceptione){
}
}
}

publicstaticvoidmain(String[]args)throwsException{
//intip=str2Ip("192.168.0.1");
//System.out.println(ip2long(ip));
//format("ipdata.txt","result.dat");
IPTooltool=newIPTool("result.dat");
IPInfoinfo=tool.find("211.155.224.222");
System.out.println(info.getCountry()+""+info.getLocal());
}
}

classIPOriginInfo{
publicintstartIP;
publicintendIP;
publicStringcountry;
publicStringlocal;
}

classIPFile{
publicstaticfinalintMAGIC=0x05080321;
publicstaticfinalintHEADER_SIZE=20;
publicstaticfinalintIP_INFO_SIZE=12;
publicstaticfinalintINDEX_SIZE=6;

publicfinalintmagic=MAGIC;
publicinttotalRecords;
publicintipOffset=HEADER_SIZE;
publicintindexOffset;
publicintdataOffset;

intdataCount;
intipCount;
longminIP;
longmaxIP;
}





IPInfo.java
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
*创立日期2004-10-23
*
*/
packagestarfire.proxy.ip;

/**
*@authorstarfire
*
*/
publicclassIPInfo{

privateStringip;
privateStringcountry="";
privateStringlocal="";



/**
*@return前往country。
*/
publicStringgetCountry(){
returncountry;
}
/**
*@paramcountry要设置的country。
*/
publicvoidsetCountry(Stringcountry){
this.country=country;
}
/**
*@return前往ip。
*/
publicStringgetIp(){
returnip;
}
/**
*@paramip要设置的ip。
*/
publicvoidsetIp(Stringip){
this.ip=ip;
}
/**
*@return前往local。
*/
publicStringgetLocal(){
returnlocal;
}
/**
*@paramlocal要设置的local。
*/
publicvoidsetLocal(Stringlocal){
this.local=local;
}
}


用IPTool的format(StringdataPath,StringtargetPath)可将原始数据文件转化为外部利用格局.



java是一种面向对象的编程语言，优点是可移植性比较高，最初设计时就是本着一次编写到处执行设计的。可以开发各种应用程序和游戏，不过速度没有c++快，所以一般是不用java来编写应用程序和电脑游戏。

Java是一种计算机编程语言，拥有跨平台、面向对java

Java是一种计算机编程语言，拥有跨平台、面向对java

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

还好，SUN提供了Javabean可以把你的JSP中的 Java代码封装起来，便于调用也便于重用。

是一种使网页(Web Page)由静态(Static)转变为动态(Dynamic)的语言

设计模式是高级程序员真正掌握面向对象核心思想的必修课。设计模式并不是一种具体"技术",它讲述的是思想，它不仅仅展示了接口或抽象类在实际案例中的灵活应用和智慧

是一种使网页(Web Page)产生生动活泼画面的语言

所以现在应用最广泛又最好学的就是J2EE了。 J2EE又包括许多组件，如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。要学习起来可不是一两天的事。那么又该如何学习J2EE呢？当然Java语法得先看一看的，I/O包，Util包，Lang包你都熟悉了吗？然后再从JSP学起。