随笔-23  评论-0  文章-5  trackbacks-0
  2018年4月20日

关于http请求超时字段定义

一、connectionrequesttimeout 超时
httpclient 使用连接池来管理连接，这个时间是从连接池获取连接的超时时间，可以联想从数据库连接池获取数据库连接。

二、connecttimeout 超时
建立连接超时，客户端和服务器间建立连接进行的三次握手完成的时间

三、sockettimeout 超时
数据传输过程中数据包之间间隔的最大时间，http响应报文可能有多个小报文组成，
如果传输报文的间隔时间超过设置这个时间，会报 java.net.sockettimeoutexception: read timed out 异常的
posted @ 冯威威 阅读(320) | |  
  2015年11月20日
提示：编写eclipse常用快捷键写成文档，主要是为了自己熟悉一下这些快捷键，方便以后查找和编程中使用！
一、编辑类快捷键
1、ctrl 1 快速修复，可以解决很多问题，例如import类、try catch包围等。
2、ctrl shift f 格式化当前代码。
3、ctrl shift m 添加类的import引入。
4、ctrl shift m 组织类的import引入，既有ctrl shift m 的作用，又可以帮你去除没有用的引入。
5、ctrl y 重做与ctrl z 相反的作用。
6、alt / 内容辅助
7、ctrl d 删除当前行或者选中的多行
8、alt down 当前行和下面一行交换位置
9、alt up 当前行和上面一行交换位置
10、shift enter 在当前行的下一行插入空行
11、ctrl / 注释当前行，再次按则取消注释
二、选择快捷键
1、alt shift up 选择封装元素
2、alt shift left 选择上一个元素
3、alt shift right选择下一个元素
4、shift left 从光标处开始往左选择字符串
5、shift right 从光标处开始往右选择字符串
6、ctrl shift left 选中光标左边的单词
7、ctrl shift right 选中光标右边的单词
 
三、移动快捷键
1、ctrl left 光标移到左边单词的开头，
2、ctrl right 光标移到右边单词的末尾。
 
四、搜索快捷键
1、ctrl k 参照选中的文字快速定位到下一个，如果没有选中文字则搜索上一次使用搜索的文字。
2、ctrl shift k 参照选中的文字快速定位到上一个。
3、ctrl j 正向增量查找，按下这个快捷键后，你所输入的每个字母编辑器都提供快速匹配到某个单词，如果没有在状态栏中显示没有找到，退出这个模式按esc键。
4、ctrl shift j 反向增量查找
5、ctrl shift u 列出所有包含字符串的行
6、ctrl g 工作区中的声明
7、ctrl shift g 工作区中的引用
 
五、导航快捷键
1、ctrl shift t 搜索类
2、ctrl shift r 搜索工程中的文件
3、ctrl e 快速显示当前编辑区的下拉列表
4、f4 打开类型层次结构
5、f3 跳转到声明处
6、alt left 前一个编辑页面
7、alt right 下一个编辑页面
8、ctrl pageup/pagedown在编辑器中，切换已经打开的文件
 
六、调试快捷键
1、f5 单步跳入
2、f6 单步跳过
3、f7 单步还回
4、f8 继续
5、ctrl shift d 显示变量的值
6、ctrl shift b 在当前行设置或者去掉断点
7、ctrl r 运行至行，比较好用可以省好多的断点
 
七、重构快捷键
1、alt shift r 重命名类名、方法名、属性（变量）名。
2、alt shift m 把一段函数内的代码抽取成方法，这是重构里面最常用的方法之一，特别是对于一大坨代码很有用。
3、alt shift c 修改函数结构，比较实用有n个函数调用了这个方法修改一次就行了。
4、alt shift l 抽取本地变量，可以直接把一些魔法数字和字符串抽取成一个变量，尤其是多出调用的时候。
5、alt shift f 把class中的局部变量变为全局变量
6、alt shift i 合并变量，将创建简化
7、alt shift z 撤销重构
 
八、其他快捷键
1、alt enter 显示当前选择资源的属性，在windows下查看文件的属性就是这个快捷键，通常可以用来查看文件在windows中的实际路径。
2、ctrl up文本编辑器向上滚行
3、ctrl down 文本编辑器向下滚行
4、ctrl m 最大化当前的edit或者view，再按则缩小
5、ctrl o 快速显示outline
6、ctrl t 快速显示当前类的继承结构，选中接口方法按下这快捷可以跳转到实现类，在项目dao中经常用。
7、ctrl w 关闭当前editer
8、ctrl l 文本编辑器转至行
9、f2 显示工具提示描述，选择类或者变量按下该键会有提示出来
posted @ 冯威威 阅读(408) | |  
  2015年8月18日

今天遇到调用encodeurl调用二次的疑问，虽然之前知道要调用二次，但是具体不是太清楚里面具体的运行过程，这是转载的这个写的比较详细，把整个运行过程详细解读了一下，非常不错所以转载过了供其他人分享。
.encodeurl函数主要是来对uri来做转码，它默认是采用的utf-8的编码.
. utf-8编码的格式:一个汉字来三个字节构成，每一个字节会转换成16进制的编码，同时添加上%号.

假设页面端输入的中文是一个“中”，按照下面步骤进行解码

1.第一次encodeuri，按照utf-8方式获取字节数组变成[-28,-72-83]，对字节码数组进行遍历，把每个字节转化成对应的16进制数，这样就变成了[e4,b8,ad],最后变成[�,�,�]  此时已经没有了多字节字符，全部是单字节字符。

2、第二次encodeuri，进行编码，会把%看成一个转义字符，并不编码%以后字符，会把%编码成%.把数组最后变成[%e4,%b8,%ad]然后就把处理后的数据[%e4,%b8,%ad]发往服务器端，
当应用服务器调用getparameter方法，getparameter方法会去向应用服务器请求参数
应用服务器最初获得的就是发送来的[%e4,%b8,%ad]，应用服务器会对这个数据进行urldecode操作，应用服务器进行解码的这一次，不管是按照utf-8，还是gbk，还是iso-8859，,都能得到[�,�,�]，因为都会把%解析成%.并把这个值返回给getparameter方法

3\、再用utf-8解码一次，就得到"中"了。

想想看，如果不编码两次，当服务器自动解码的时候，假如是按照iso-8859去解码utf-8编码的东西，就是会出现乱码。

js:

[sql] 
  1. document.authorityform.action = basepath3 "user_viewuser.do?id=" id "&rolename=" encodeuri(encodeuri(rolename)) "&roletype=" roletype;  


java后台：
   

[sql] 
  1. rolename = java.net.urldecoder.decode(getrequest().getparameter("rolename"),"utf-8");  
posted @ 冯威威 阅读(392) | |  
  2015年6月11日

 

一、概念

 

 

　　 annontation是java5开始引入的新特征。中文名称一般叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。

 

　　更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或框架使用的。

 

annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

 

二、原理

 

　　annotation其实是一种接口。通过java的反射机制相关的api来访问annotation信息。相关类（框架或工具中的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。

 

　　annotation是不会影响程序代码的执行，无论annotation怎么变化，代码都始终如一地执行。

 

　　java语言解释器在工作时会忽略这些annotation，因此在jvm 中这些annotation是“不起作用”的，只能通过配套的工具才能对这些annontaion类型的信息进行访问和处理。

 

　　annotation与interface的异同：

 

　　　　1）、annotation类型使用关键字@interface而不是interface。

 

　　这个关键字声明隐含了一个信息：它是继承了java.lang.annotation.annotation接口，并非声明了一个interface

 

　　　　2）、annotation类型、方法定义是独特的、受限制的。

 

　　annotation 类型的方法必须声明为无参数、无异常抛出的。这些方法定义了annotation的成员：方法名成为了成员名，而方法返回值成为了成员的类型。而方法返回值类型必须为primitive类型、class类型、枚举类型、annotation类型或者由前面类型之一作为元素的一维数组。方法的后面可以使用 default和一个默认数值来声明成员的默认值，null不能作为成员默认值，这与我们在非annotation类型中定义方法有很大不同。

 

　　annotation类型和它的方法不能使用annotation类型的参数、成员不能是generic。只有返回值类型是class的方法可以在annotation类型中使用generic，因为此方法能够用类转换将各种类型转换为class。

 

　　　　3）、annotation类型又与接口有着近似之处。

 

　　它们可以定义常量、静态成员类型（比如枚举类型定义）。annotation类型也可以如接口一般被实现或者继承。

 

 

三、应用场合

 

　　annotation一般作为一种辅助途径，应用在软件框架或工具中，在这些工具类中根据不同的 annontation注解信息采取不同的处理过程或改变相应程序元素（类、方法及成员变量等）的行为。

 

　　例如：junit、struts、spring等流行工具框架中均广泛使用了annontion。使代码的灵活性大提高。

 

 

 四、常见标准的annotation

 

　　从java5版本开始，自带了三种标准annontation类型,

 

　　　　（1）、override

 

　　java.lang.override 是一个marker annotation类型，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种annotation在一个没有覆盖父类方法的方法时，java编译器将以一个编译错误来警示。

 

　　这个annotaton常常在我们试图覆盖父类方法而确又写错了方法名时加一个保障性的校验过程。

 

　　　　（2）、deprecated

 

　　deprecated也是一种marker annotation。当一个类型或者类型成员使用@deprecated修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的 “延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为 @deprecated，但编译器仍然要报警。

 

　　注意：@deprecated这个annotation类型和javadoc中的 @deprecated这个tag是有区别的：前者是java编译器识别的，而后者是被javadoc工具所识别用来生成文档（包含程序成员为什么已经过时、它应当如何被禁止或者替代的描述）。

 

　　　　（3）、suppresswarnings

 

　　此注解能告诉java编译器关闭对类、方法及成员变量的警告。

 

　　有时编译时会提出一些警告，对于这些警告有的隐藏着bug，有的是无法避免的，对于某些不想看到的警告信息，可以通过这个注解来屏蔽。

 

　　suppresswarning不是一个marker annotation。它有一个类型为string[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-xlint选项有效的警告名也同样对@suppresswarings有效，同时编译器忽略掉无法识别的警告名。

 

　　annotation语法允许在annotation名后跟括号，括号中是使用逗号分割的name=value对用于为annotation的成员赋值：

 

代码：

 

@suppresswarnings(value={"unchecked","fallthrough"})

publicvoid linttrap() { /* sloppy method body omitted */ }

 

 

 

在这个例子中suppresswarnings annotation类型只定义了一个单一的成员，所以只有一个简单的value={...}作为name=value对。又由于成员值是一个数组，故使用大括号来声明数组值。

 

 

注意：我们可以在下面的情况中缩写annotation：当annotation只有单一成员，并成员命名为"value="。这时可以省去"value="。比如将上面的suppresswarnings annotation进行缩写：

 

代码：

 

@suppresswarnings({"unchecked","fallthrough"})

 

 

 

 

如果suppresswarnings所声明的被禁止警告个数为一个时，可以省去大括号：

 

 

 

@suppresswarnings("unchecked")

 

 

 

五、自定义annontation示例

 

  示例共涉及四个类：

　　清单1:author.java

package com.magc.annotation;

import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

    /**
     * 定义作者信息，name和group
     * @author magc
     *
     */
    @retention(retentionpolicy.runtime)
    @target(elementtype.method)
    @documented
public @interface author {

        string name();
        string group();
}

　　清单2:description.java

/**
 * 
 */
package com.magc.annotation;

import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

/**
 * @author magc
 *
 * 定义描述信息 value
 */
    @retention(retentionpolicy.runtime)
    @target(elementtype.type)
    @documented
    
public @interface description {
        string value();
}

清单3:utility.java

package com.magc.annotation;

    @description(value ="这是一个有用的工具类")
publicclass utility {

        @author(name ="haoran_202",group="com.magc")
        public string work()
        {
            return"work over!";
        }
        
        
    
}

注：这是个普通的java类，运行了@description和@author注解。

清单3:analysisannotation.java

package com.magc.annotation;

import java.lang.reflect.method;

publicclass analysisannotation {
    /**
     * 在运行时分析处理annotation类型的信息
     * 
     * 
     */
    publicstaticvoid main(string[] args) {
        try {
                //通过运行时反射api获得annotation信息
                class rt_class = class.forname("com.magc.annotation.utility");
                method[] methods = rt_class.getmethods();
                
                boolean flag = rt_class.isannotationpresent(description.class);
                
                if(flag)
                {
                    description description = (description)rt_class.getannotation(description.class);
                    system.out.println("utility's description--->"description.value());
                    for (method method : methods) {
                        if(method.isannotationpresent(author.class))
                        {
                            author author = (author)method.getannotation(author.class);
                            system.out.println("utility's author--->"author.name()" from "author.group());
                            
                        }
                    }
                }
            
            
            } catch (classnotfoundexception e) {
                e.printstacktrace();
            }
    }

}

注：这是个与自定义@description和@author配套的基础框架或工具类，通过此类来获得与普通java类utility.java关联的信息,即描述和作者。

运行analysisannotation,输出结果为：

utility's description--->这是一个有用的工具类
utility's author--->haoran_202 from com.magc

posted @ 冯威威 阅读(233) | |  
  2015年3月12日
在oracle 数据库中有一种方法可以实现级联查询
select *                //要查询的字段
from table              //具有子接点id与父接点id的表 
start with selfid=id      //给定一个startid(字段名为子接点id，及开始的id号)
connect by prior selfid=parentid       //联接条件为子接点等于父接点，不能反

这个sql主要用于菜单的级联查询，给一个父接点可以查出所有的子接点。及子接点的子接点，一查到底，很实用。不过呢这个程序只能在oracle里面用，我目前还不知道在其它数据库里是怎么调用的。等我找到了，再贴出来与大家分享。
这个程序，估计好多人看不明白，其实放了这么久我也一时没看明白，重新测了一下，补充说明一下，不然我下次又看不懂了。
以一个windows系统的菜单为例。我那一个这样的表menu。
说明：
mid:菜单的id号
mname：菜单名称
mpid：菜单的
quickey：快捷键
validate:权限表（存放userid,或者角色id）
mid mname mpid quickey validate                                                                  
1 文件   ctrl f 1，2，3，4，11，23，45
2 编辑   ctrl e  
3 新建 1 alt w  
4 文件夹 3  

 

如果我想知道在“文件”菜单下有那些子菜单的话。我就可以这样用这个sql程序：
select * from menu
start with mid=1     
connect by prior mid=mpid;
这样就可以把 “文件”里的子菜单全部列出来了。当然实际应用不会这么简单，如附加其实条件，尤其是权限管理，这时根据你的系统要求，是对个个验证，还是对角色验证，把这些人的id放在validate这个字段里，组成一个字符串，n个id用逗号隔开，（注意，在往数据库保存时要注意对字符串处理一下，截取掉最后一个逗号这样可以节省很多麻烦）
select * from menu
where validate in(……)
and mid in(
   select mid from menu  //这里不能用*号了。
   start with mid=1     
   connect by prior mid=mpid;
)
最后再补充一点关于随机查询的代码
select * from user order by sys_guid()
posted @ 冯威威 阅读(1438) | |  
  2015年1月21日

今天看到某网友关于“如何以java实现网页截图技术”的咨询帖，由于出现该咨询的地点非常不适合较长回复，故以博文形式回答。

 

事实上，如果您想以java实现网页截图，也就是“输入一段网址，几秒钟过后就能截取一张网页缩略图”的效果。那么，您至少有3种方式可以选择。

 

1、最直接的方式——使用robot

 

方法详解：该方法利用robat提供的强大桌面操作能力，硬性调用浏览器打开指定网页，并将网页信息保存到本地。

 

优势：简单易用，不需要任何第三方插件。

 

缺点：不能同时处理大量数据，技术含量过低，属于应急型技巧。

 

实现方法：使用如下代码即可


 

 

[java]
  1. public static void main(string[] args) throws malformedurlexception,  
  2.         ioexception, urisyntaxexception, awtexception {  
  3.     //此方法仅适用于jdk1.6及以上版本   
  4.     desktop.getdesktop().browse(  
  5.             new .touri());  
  6.     robot robot = new robot();  
  7.     robot.delay(10000);  
  8.     dimension d = new dimension(toolkit.getdefaulttoolkit().getscreensize());  
  9.     int width = (int) d.getwidth();  
  10.     int height = (int) d.getheight();  
  11.     //最大化浏览器   
  12.     robot.keyrelease(keyevent.vk_f11);  
  13.     robot.delay(2000);  
  14.     image image = robot.createscreencapture(new rectangle(0, 0, width,  
  15.             height));  
  16.     bufferedimage bi = new bufferedimage(width, height,  
  17.             bufferedimage.type_int_rgb);  
  18.     graphics g = bi.creategraphics();  
  19.     g.drawimage(image, 0, 0, width, height, null);  
  20.     //保存图片   
  21.     imageio.write(bi, "jpg", new file("google.jpg"));  
  22. }  

 

 

2、最常规的方式——利用jni，调用第三方c/c 组件

方法详解：目前来讲，java领域对于网页截图组件的开发明显不足（商机？），当您需要完成此种操作时，算得上碰到了java的软肋。但是，众所周知java也拥有强大的jni能力，可以轻易将c/c 开发的同类组件引为己用。

优势：实现简单，只需要封装对应的dll文件，就可以让java实现同类功能。

 

劣势：同其他jni实现一样，在跨平台时存在隐患，而且您的程序将不再属于纯java应用。

 

实现方法：可参见此用例，具体封装何种c/c 组件请自行选择。

 

ps：示例来源于aca html to image converter项目（ ），这是一个收费的html转image第三方组件，但封装方式在java中大同小异。

 

引用jni封装：

 

 

 

[java]
  1. import sun.awt.*;  
  2. import java.awt.*;  
  3. import javax.swing.*;  
  4. import java.awt.event.*;  
  5. import java.awt.*;  
  6. import java.awt.peer.*;  
  7. public class snap  
  8. {  
  9.   static  
  10.   {  
  11.     system.loadlibrary("snap");  
  12.   }  
  13.   public static void main( string[] argv )  
  14.   {  
  15.     snap t_xsnap = new snap();  
  16.     t_xsnap.start("http://www.google.com", "snapshot-google.png");  
  17.   }  
  18.   public native void start(string pi_strurl, string pi_strimagename);  
  19. }  

 

 

cpp部分的实现：

 

 

 

[java]
  1. #include   
  2. #include   
  3. #include "snap.h"  
  4. #pragma comment(lib,"atl.lib")  
  5. #import "./../../acawebthumb.dll" no_namespace  
  6. jniexport void jnicall java_snap_start(jnienv *penv, jobject, jstring pi_strurl, jstring pi_strfilename)  
  7. {  
  8.   coinitialize(0);  
  9.   _bstr_t t_strurl = penv->getstringutfchars(pi_strurl, 0);  
  10.   _bstr_t t_strfilename = penv->getstringutfchars(pi_strfilename, 0);      
  11.   ithumbmakerptr html_converter = null;  
  12.   hresult hr = html_converter.createinstance(l"acawebthumb.thumbmaker");      
  13.   if (succeeded(hr))  
  14.   {   
  15.     html_converter->set;  
  16.     if ( 0 == html_converter->startsnap() )  
  17.       html_converter->saveimage(t_strfilename);  
  18.   }  
  19.   if (html_converter)  
  20.     html_converter.release();  
  21.   couninitialize();           
  22. }  

 

 

以该组件图像化yahoo界面的效果图：

 

00


3、最扎实的方法——自行解析html标记，并将其图像化

 

方法详解：众所周知，html之所以在浏览器中以具体的网页格式出现，并非服务器端传了一整个应用到客户端，而是源自于浏览器对于客户端自行解析的结果。因此，只要我们将对应的解析一一实现，那么将网页图形化，就将不是什么难事。


优势：纯java实现，一劳永逸，一旦开发完成则永远通用，而且有一定的商用价值。

 

劣势：开发费时，且需要针对不同语法做精确分析，才能保证输出的基本正确。尤其在涉及到javascript解析时，难度将尤其增大。

 

实现方法：目前尚无具体案例可供参考。但是，由于java有jdic之类的浏览器项目存在（ ），而java图形界面又属绘制生成。从理论上说，我们可以将所有具备graphics的组件图形化保存。

 

而如果自行解析，那么您需要建立html解析器（或使用第三方的，万幸java在这方面的组件很多），了解java2d机制，了解何时该使用drawstring绘制文字，何时又该使用drawimage插入图片等等。

 


补充：

 

这是一个利用内置浏览器截图的示例，使用了djnativeswing组件。

 

示例工程下载地址（eclipse工程，含lib）：

 

 

 

 

[java]
  1. import java.awt.borderlayout;  
  2. import java.awt.dimension;  
  3. import java.awt.flowlayout;  
  4. import java.awt.image.bufferedimage;  
  5. import java.io.file;  
  6. import java.io.ioexception;  
  7. import javax.imageio.imageio;  
  8. import javax.swing.jframe;  
  9. import javax.swing.jpanel;  
  10. import javax.swing.swingutilities;  
  11. import chrriis.dj.nativeswing.swtimpl.nativecomponent;  
  12. import chrriis.dj.nativeswing.swtimpl.nativeinterface;  
  13. import chrriis.dj.nativeswing.swtimpl.components.jwebbrowser;  
  14. import chrriis.dj.nativeswing.swtimpl.components.webbrowseradapter;  
  15. import chrriis.dj.nativeswing.swtimpl.components.webbrowserevent;  
  16. public class main extends jpanel {  
  17.     /** 
  18.      *  
  19.      */  
  20.     private static final long serialversionuid = 1l;  
  21.     // 行分隔符   
  22.     final static public string ls = system.getproperty("line.separator", "/n");  
  23.     // 文件分割符   
  24.     final static public string fs = system.getproperty("file.separator", "//");  
  25.     //以javascript脚本获得网页全屏后大小   
  26.     final static stringbuffer jsdimension;  
  27.       
  28.     static {  
  29.         jsdimension = new stringbuffer();  
  30.         jsdimension.append("var width = 0;").append(ls);  
  31.         jsdimension.append("var height = 0;").append(ls);  
  32.         jsdimension.append("if(document.documentelement) {").append(ls);  
  33.         jsdimension.append(  
  34.                         "  width = math.max(width, document.documentelement.scrollwidth);")  
  35.                 .append(ls);  
  36.         jsdimension.append(  
  37.                         "  height = math.max(height, document.documentelement.scrollheight);")  
  38.                 .append(ls);  
  39.         jsdimension.append("}").append(ls);  
  40.         jsdimension.append("if(self.innerwidth) {").append(ls);  
  41.         jsdimension.append("  width = math.max(width, self.innerwidth);")  
  42.                 .append(ls);  
  43.         jsdimension.append("  height = math.max(height, self.innerheight);")  
  44.                 .append(ls);  
  45.         jsdimension.append("}").append(ls);  
  46.         jsdimension.append("if(document.body.scrollwidth) {").append(ls);  
  47.         jsdimension.append(  
  48.                 "  width = math.max(width, document.body.scrollwidth);")  
  49.                 .append(ls);  
  50.         jsdimension.append(  
  51.                 "  height = math.max(height, document.body.scrollheight);")  
  52.                 .append(ls);  
  53.         jsdimension.append("}").append(ls);  
  54.         jsdimension.append("return width   ':'   height;");  
  55.     }  
  56.   //djnativeswing组件请于http://djproject.sourceforge.net/main/index.html下载   
  57.     public main(final string url, final int maxwidth, final int maxheight) {  
  58.         super(new borderlayout());  
  59.         jpanel webbrowserpanel = new jpanel(new borderlayout());  
  60.         final string filename = system.currenttimemillis()   ".jpg";  
  61.         final jwebbrowser webbrowser = new jwebbrowser(null);  
  62.         webbrowser.setbarsvisible(false);  
  63.         webbrowser.navigate(url);  
  64.         webbrowserpanel.add(webbrowser, borderlayout.center);  
  65.         add(webbrowserpanel, borderlayout.center);  
  66.         jpanel panel = new jpanel(new flowlayout(flowlayout.center, 4, 4));  
  67.         webbrowser.addwebbrowserlistener(new webbrowseradapter() {  
  68.             // 监听加载进度   
  69.             public void loadingprogresschanged(webbrowserevent e) {  
  70.                 // 当加载完毕时   
  71.                 if (e.getwebbrowser().getloadingprogress() == 100) {  
  72.                     string result = (string) webbrowser  
  73.                             .executejavascriptwithresult(jsdimension.tostring());  
  74.                     int index = result == null ? -1 : result.indexof(":");  
  75.                     nativecomponent nativecomponent = webbrowser  
  76.                             .getnativecomponent();  
  77.                     dimension originalsize = nativecomponent.getsize();  
  78.                     dimension imagesize = new dimension(integer.parseint(result  
  79.                             .substring(0, index)), integer.parseint(result  
  80.                             .substring(index   1)));  
  81.                     imagesize.width = math.max(originalsize.width,  
  82.                             imagesize.width   50);  
  83.                     imagesize.height = math.max(originalsize.height,  
  84.                             imagesize.height   50);  
  85.                     nativecomponent.setsize(imagesize);  
  86.                     bufferedimage image = new bufferedimage(imagesize.width,  
  87.                             imagesize.height, bufferedimage.type_int_rgb);  
  88.                     nativecomponent.paintcomponent(image);  
  89.                     nativecomponent.setsize(originalsize);  
  90.                     // 当网页超出目标大小时   
  91.                     if (imagesize.width > maxwidth  
  92.                             || imagesize.height > maxheight) {  
  93.                         //截图部分图形   
  94.                         image = image.getsubimage(0, 0, maxwidth, maxheight);  
  95.                         /*此部分为使用缩略图 
  96.                         int width = image.getwidth(), height = image 
  97.                             .getheight(); 
  98.                          affinetransform tx = new affinetransform(); 
  99.                         tx.scale((double) maxwidth / width, (double) maxheight 
  100.                                 / height); 
  101.                         affinetransformop op = new affinetransformop(tx, 
  102.                                 affinetransformop.type_nearest_neighbor); 
  103.                         //缩小 
  104.                         image = op.filter(image, null);*/  
  105.                     }  
  106.                     try {  
  107.                         // 输出图像   
  108.                         imageio.write(image, "jpg", new file(filename));  
  109.                     } catch (ioexception ex) {  
  110.                         ex.printstacktrace();  
  111.                     }  
  112.                     // 退出操作   
  113.                     system.exit(0);  
  114.                 }  
  115.             }  
  116.         }  
  117.         );  
  118.         add(panel, borderlayout.south);  
  119.     }  
  120.     public static void main(string[] args) {  
  121.         nativeinterface.open();  
  122.         swingutilities.invokelater(new runnable() {  
  123.             public void run() {  
  124.                 // swt组件转swing组件，不初始化父窗体将无法启动webbrowser   
  125.                 jframe frame = new jframe("以dj组件保存指定网页截图");  
  126.                 // 加载指定页面，最大保存为640x480的截图   
  127.                 frame.getcontentpane().add(  
  128.                         new main("http://blog.csdn.net/cping1982", 640, 480),  
  129.                         borderlayout.center);  
  130.                 frame.setsize(800, 600);  
  131.                 // 仅初始化，但不显示   
  132.                 frame.invalidate();  
  133.                 frame.pack();  
  134.                 frame.setvisible(false);  
  135.             }  
  136.         });  
  137.         nativeinterface.runeventpump();  
  138.     }  
  139. }  

 

 

 

posted @ 冯威威 阅读(399) | |  
  2015年1月4日
public httpservletresponse download(string path, httpservletresponse response) {
        try {
            // path是指欲下载的文件的路径。
            file file = new file(path);
            // 取得文件名。
            string filename = file.getname();
            // 取得文件的后缀名。
            string ext = filename.substring(filename.lastindexof(".")  1).touppercase();

            // 以流的形式下载文件。
            inputstream fis = new bufferedinputstream(new fileinputstream(path));
            byte[] buffer = new byte[fis.available()];
            fis.read(buffer);
            fis.close();
            // 清空response
            response.reset();
            // 设置response的header
            response.addheader("content-disposition", "attachment;filename="  new string(filename.getbytes()));
            response.addheader("content-length", ""  file.length());
            outputstream toclient = new bufferedoutputstream(response.getoutputstream());
            response.setcontenttype("application/octet-stream");
            toclient.write(buffer);
            toclient.flush();
            toclient.close();
        } catch (ioexception ex) {
            ex.printstacktrace();
        }
        return response;
    }

    public void downloadlocal(httpservletresponse response) throws filenotfoundexception {
        // 下载本地文件
        string filename = "operator.doc".tostring(); // 文件的默认保存名
        // 读到流中
        inputstream instream = new fileinputstream("c:/operator.doc");// 文件的存放路径
        // 设置输出的格式
        response.reset();
        response.setcontenttype("bin");
        response.addheader("content-disposition", "attachment; filename=\""   filename   "\"");
        // 循环取出流中的数据
        byte[] b = new byte[100];
        int len;
        try {
            while ((len = instream.read(b)) > 0)
                response.getoutputstream().write(b, 0, len);
            instream.close();
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    public void downloadnet(httpservletresponse response) throws malformedurlexception {
        // 下载网络文件
        int bytesum = 0;
        int byteread = 0;

        url url = new ;

        try {
            urlconnection conn = url.openconnection();
            inputstream instream = conn.getinputstream();
            fileoutputstream fs = new fileoutputstream("c:/abc.gif");

            byte[] buffer = new byte[1204];
            int length;
            while ((byteread = instream.read(buffer)) != -1) {
                bytesum  = byteread;
                system.out.println(bytesum);
                fs.write(buffer, 0, byteread);
            }
        } catch (filenotfoundexception e) {
            e.printstacktrace();
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
//支持在线打开文件的一种
public void download(string filepath, httpservletresponse response, boolean isonline) throws exception {
        file f = new file(filepath);
        if (!f.exists()) {
            response.senderror(404, "file not found!");
            return;
        }
        bufferedinputstream br = new bufferedinputstream(new fileinputstream(f));
        byte[] buf = new byte[1024];
        int len = 0;

        response.reset(); // 非常重要
        if (isonline) { // 在线打开方式
            url u = new ;
            response.setcontenttype(u.openconnection().getcontenttype());
            response.setheader("content-disposition", "inline; filename="  f.getname());
            // 文件名应该编码成utf-8
        } else { // 纯下载方式
            response.setcontenttype("application/x-msdownload");
            response.setheader("content-disposition", "attachment; filename="  f.getname());
        }
        outputstream out = response.getoutputstream();
        while ((len = br.read(buf)) > 0)
            out.write(buf, 0, len);
        br.close();
        out.close();
    }
方式

posted @ 冯威威 阅读(174) | |  
  2014年7月29日
原始的message.xml
xml version="1.0" encoding="utf-8"?><users>
    <messages>
        <sendname>senduserssendname>
        <receivename>snakereceivename>
        <date>2007-12-04 12:20:00date>
        <status>1status>
        <message>this is contentmessage>
    messages>
users>

java程序
import java.io.file;

import javax.xml.parsers.documentbuilder;
import javax.xml.parsers.documentbuilderfactory;
import javax.xml.transform.transformer;
import javax.xml.transform.transformerfactory;
import javax.xml.transform.dom.domsource;
import javax.xml.transform.stream.streamresult;

import org.w3c.dom.document;
import org.w3c.dom.node;
import org.w3c.dom.nodelist;

public class updatexml {
    public static boolean doc2xmlfile(document document, string filename) {
        boolean flag = true;
        try {
           
            transformerfactory tfactory = transformerfactory.newinstance();
            transformer transformer = tfactory.newtransformer();
           
            // transformer.setoutputproperty(outputkeys.encoding, "gb2312");
            domsource source = new domsource(document);
            streamresult result = new streamresult(new file(filename));
            transformer.transform(source, result);
        } catch (exception ex) {
            flag = false;
            ex.printstacktrace();
        }
        return flag;
    }

    public static document load(string filename) {
        document document = null;
        try {
            documentbuilderfactory factory = documentbuilderfactory
                    .newinstance();
            documentbuilder builder = factory.newdocumentbuilder();
            document = builder.parse(new file(filename));
            document.normalize();
        } catch (exception ex) {
            ex.printstacktrace();
        }
        return document;
    }

   
    public static void xmlupdatedemo() {
        document document = load("message.xml");
        node root = document.getdocumentelement();
       
        if (root.haschildnodes()) {
           
            nodelist ftpnodes = root.getchildnodes();
           
            for (int i = 0; i < ftpnodes.getlength(); i) {
                nodelist ftplist = ftpnodes.item(i).getchildnodes();
                for (int k = 0; k < ftplist.getlength(); k) {
                    node subnode = ftplist.item(k);
                   
                    // if (subnode.getnodetype()==node.element_node&&subnode.
                    // getnodename()=="ftp-chn")
                    // {
                    // ftpnodes.item(i).removechild(subnode);
                    // }
                   
                    if (subnode.getnodetype() == node.element_node
                            && subnode.getnodename() == "status") {
                        subnode.getfirstchild().setnodevalue("9");
                    }
                }

            }
        }

        doc2xmlfile(document, "message.xml");
    }

    public static void main(string args[]) throws exception {
        updatexml.xmlupdatedemo();
    }
}

修改后的message.xml
xml version="1.0" encoding="utf-8"?><users>
    <messages>
        <sendname>senduserssendname>
        <receivename>snakereceivename>
        <date>2007-12-04 12:20:00date>
        <status>9status>
        <message>this is contentmessage>
    messages>
users>
posted @ 冯威威 阅读(504) | |  
     摘要: 一、概述 ant 是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具，大多用于java环境中的软件开发。在实际软件开发中，有很多地方可以用到ant。   开发环境： system：windows jdk：1.6 ide：eclipse ant：1.9.1   email：hoojo_@126.com blog：http://blog....  
posted @ 冯威威 阅读(254) | |  
     摘要: ant是一个apache基金会下的跨平台的构件工具，它可以实现项目的自动构建和部署等功能。在本文中，主要让读者熟悉怎样将ant应用到java项目中，让它简化构建和部署操作。 一．             安装与配置 下载地址：http://ant.apache.org...  
posted @ 冯威威 阅读(3199) | |  
仅列出标题  下一页
powered by: 模板提供： 凯发天生赢家一触即发官网 copyright ©2023 冯威威
网站地图