宇托的狗窝 » Java

Servlet的线程安全

yutuo — Sun, 22 Jan 2012 09:10:45 +0000

　　在一般情况下，Servlet容器只创建一个实例，如果有多个客户请求同时访问这个Servlet，会采用多线程来访问这一个Servlet。在这种情况下，就会有线程安全问题。

　　比如，定义一个Servlet的类变量user，然后在doPost或者doGet里处理的话，当线程转换时就会出现很怪的情况。如下代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @WebServlet("/ServletSecurity") public class ServletSecurity extends HttpServlet { private static final long serialVersionUID = -1841665725196115690L; private String user; protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.user = request.getParameter("user"); PrintWriter out = response.getWriter(); out.println(this.user + ", Welcome."); } }

　　在上面这段代码里，有些人认为没有把user变量设为静态变量就不会出现线程问题了。其实不是的，因为Servlet容器只建一个实例，在线程间切换时就会出问题。如A和B两个人同时登录时，A先执行，在this.user = request.getParameter("user");把user设为A；然后线程切换了，B把user设为B，执行完之后再执行A，就会输出B, Welcome。

　　解决上面问题的方法就是，不要在Servlet定义可写的类变量，当然可写的静态变量就更不能定义了。

参考资料：孙鑫《Java Web开发详解——XML XSLT Servlet JSP深入剖析实例应用》第11章开发线程安全的Servlet

Servlet的异常处理

yutuo — Sun, 15 Jan 2012 06:22:22 +0000

　　在之前，我一般用Try…Catch…来处理Servlet的异常。最近在看孙鑫老师写的《Java Web开发详解——XML XSLT Servlet JSP深入剖析实例应用》，发现还可以通过web.xml来配置Servlet的异常处理。觉得这个方法还是最好的。

　　主要是通过配置WEB-INF下web.xml的error-page来达到我们的异常处理。error-page下有三个标签error-code，exception-type，location。其中location是必需的，用于指定异常处理画面；error-code，exception-type在一个error-page有且只能有一个，用于指定异常或者错误码。

　　如果处理画面是Servlet，我们可以通过service来处理异常。其中request参数属性里，能取到javax.servlet.error.status_code, javax.servlet.error.exception_type, javax.servlet.error.message, javax.servlet.error.exception, javax.servlet.error.request_uri, javax.servlet.error.servlet_name这六个值，具体的说明和类型，请参考测试代码。

比如，测试用的web.xml配置如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 xml version="1.0" encoding="UTF-8"?> version="3.0" 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_3_0.xsd"> 404 /ErrorPage 500 /ErrorPage java.io.IOException /ErrorPage

测试用的Servlet如下：

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 import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * Servlet implementation class ErrorPage */ @WebServlet("/ErrorPage") public class ErrorPage extends HttpServlet { private static final long serialVersionUID = 1L; protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { PrintWriter out = response.getWriter(); // HTTP协议的状态码 Integer statusCode = (Integer)request.getAttribute("javax.servlet.error.status_code"); out.println(String.format("status_code: %s", statusCode)); // 未捕获的异常类名 Class exceptionType = (Class)request.getAttribute("javax.servlet.error.exception_type"); out.println(String.format("exception_type: %s", exceptionType)); // 错误发生画面response.sendError设置的消息 // 或者未捕获的异常的消息 String message = (String)request.getAttribute("javax.servlet.error.message"); out.println(String.format("message: %s", message)); // 未捕获的异常 Throwable throwable = (Throwable)request.getAttribute("javax.servlet.error.exception"); out.println(String.format("Throwable: %s", throwable)); // 当前请求URI String requestUri = (String)request.getAttribute("javax.servlet.error.request_uri"); out.println(String.format("request_uri: %s", requestUri)); // 错误画面的Servlet String servletName = (String)request.getAttribute("javax.servlet.error.servlet_name"); out.println(String.format("servlet_name: %s", servletName)); } }

测试1：当提求画面不存在时，结果如下：

1 2 3 4 5 6 status_code: 404 exception_type: null message: /JavaWeb/HelloWorld1 Throwable: null request_uri: /JavaWeb/HelloWorld1 servlet_name: default

测试2：当提求画面发生IOException(web.xml配置)时，结果如下：

1 2 3 4 5 6 status_code: 500 exception_type: class java.io.IOException message: Test Error Msg Throwable: java.io.IOException: Test Error Msg request_uri: /JavaWeb/HelloWorld servlet_name: net.yutuo.javaweb.servlet.HelloWorld

测试3：当提求画面发生其它异常时，结果如下：

1 2 3 4 5 6 status_code: 500 exception_type: null message: Throwable: javax.servlet.ServletException: Test Error Msg request_uri: /JavaWeb/HelloWorldInput servlet_name: net.yutuo.javaweb.servlet.HelloWorldInput

根据以上的信息，写一个自己的异常画面应该是学过一点Java的就没问题了，呵呵。

参考资料：孙鑫《Java Web开发详解——XML XSLT Servlet JSP深入剖析实例应用》第10章 Servlet的异常处理机制

用ResourceBundle来读取配置文件

yutuo — Sun, 15 Jan 2012 05:27:51 +0000

　　之前不知道Java还有ResourceBundle这个类，最近一个项目，别人用了ResourceBundle来读取配置文件，还真的很方便。它可以读取相对Class目录的任何配置文件。测试代码如下：

我在包net.yutuo.java下建了一个test.properties的配置文件，内容如下：

1 test=testValue

测试用的Java文件如下：

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 import java.util.MissingResourceException; import java.util.ResourceBundle; public class PropertyTest { private static ResourceBundle resbun; static { // 绑定配置文件 resbun = ResourceBundle.getBundle("net.yutuo.java.test"); } /** * 读取配置值，如果取值失败，则返回defaultValue * @param key 索引 * @param defaultValue 默认值 * @return 配置值 */ public static String getString(String key, String defaultValue) { try { return resbun.getString(key); } catch (MissingResourceException ex) { return defaultValue; } } public static void main(String[] arg) { // 读取一个配置文件存在的值 System.out.println(getString("test", "error")); // 读取一个配置文件不存在的值 System.out.println(getString("test1", "error")); } }

结果如下：

1 2 testValue error

web.xml各个版本模板

yutuo — Thu, 12 Jan 2012 15:10:10 +0000

J2EE 2.3

1 2 3 4 5 6 xml version="1.0" encoding="ISO-8859-1"?> DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

J2EE 2.4

1 2 3 4 5 6 xml version="1.0" encoding="UTF-8"?> id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

J2EE 2.5

1 2 3 4 5 6 7 xml version="1.0" encoding="UTF-8"?> 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" version="2.5">

J2EE3.0

1 2 3 4 5 6 7 xml version="1.0" encoding="UTF-8"?> version="3.0" 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_3_0.xsd">

参考地址：http://jlcon.iteye.com/blog/890964

通过反射动态调用类的属性和方法

yutuo — Wed, 11 Jan 2012 14:02:58 +0000

　　在实际应用中，反射还是很有用的。不过反射不能访问任何公共以外的东西。也就是说反射只能访问public定义的方法和属性。

　　如下两个类，测试类TestMethod：

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 public class TestMethod { private int a; private int b; // 公共属性 public String c = "public c"; // 不带参数的构造方法 public TestMethod() { this(0, 0); } // 带参数的构造方法 public TestMethod(int a, int b) { this.a = a; this.b = b; } // 静态函数 public static int add(int a, int b) { return a + b; } // 不带参数的实例函数 public int time() { return a * b; } // 带参数的实例函数 public int plus(int c) { return a + b + c; } // 带参数的实例函数 protected int plus() { return a + b; } public String toString() { return String.format("TestMethod[a=%d, b=%d]", a, b); } }

　　如下两个类，Main测试类：

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 public class CallTestMethod { public static void main(String[] avg) throws Exception { Class testMethodClass = Class.forName(TestMethod.class.getName()); // 用不带参数的构造方法创建实例 TestMethod objA = (TestMethod) testMethodClass.newInstance(); System.out.println(objA); // 用带参数的构造方法创建实例 Constructor constr = testMethodClass.getConstructor(new Class[]{int.class, int.class}); TestMethod objB = (TestMethod) constr.newInstance(new Object[]{1, 2}); System.out.println(objB); // 访问属性 Field field = testMethodClass.getDeclaredField("c"); System.out.println(field.get(objB)); // 调用静态函数 Method method1 = testMethodClass.getMethod("add", new Class[]{int.class, int.class}); // invoke函数的第一个参数为实例，所以在静态函数调用时，第一个参数为空 System.out.println(method1.invoke(null, new Object[]{3, 4})); // 调用不带参数的实例函数 Method method2 = testMethodClass.getMethod("time"); System.out.println(method2.invoke(objB)); // 调用带参数的实例函数 Method method3 = testMethodClass.getMethod("plus", new Class[]{int.class}); System.out.println(method3.invoke(objB, new Object[]{3})); } }

执行后，结果如下：

1 2 3 4 5 6 TestMethod[a=0, b=0] TestMethod[a=1, b=2] 7 2 6 public c

Servlet获取URL地址

yutuo — Sat, 03 Dec 2011 05:55:29 +0000

　　最近在做一个系统，是在原有系统上改修的，有单独的服务器，所以不需要用数据库。而且有现成的HTML，所以基本上用一个Servlet就可以实现。根据请求的URL再调对应的Server函数，再把取到的值替换到HTML就行。

　　这里来说说用Servlet获取URL地址。在HttpServletRequest类里，有以下六个取URL的函数：

getContextPath 取得项目名
getServletPath 取得Servlet名
getPathInfo 取得Servlet后的URL名，不包括URL参数
getRequestURL 取得不包括参数的URL
getRequestURI 取得不包括参数的URI，即去掉协议和服务器名的URL

　　具体如下图：

相对应的函数的值如下：

getContextPath：/ServletTest
getServletPath：/main
getPathInfo：/index/testpage/test
getRequestURL：http://localhost:8080/ServletTest/main/index/testpage/test
getRequestURI：/ServletTest/main/index/testpage/test

关于线程Start的异常问题

yutuo — Wed, 20 Jan 2010 19:24:57 +0000

　　在线程启动后，很可能出现预计外的异常。比如RuntimeException，一般我们在程序中很少捕捉这种异常，但一旦出现，我们很希望在Log文件里能看到异常，这样的分析程序就会方便很多。
　　在Java中，可以通过setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler e)来实现对未捕捉的异常进行处理。其中UncaughtExceptionHandler的实例必须实现uncaughtException函数。在uncaughtException(Thread t, Throwable e)中实现用异常的处理。

如下程序：

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

import java.lang.Thread.UncaughtExceptionHandler;
 
public class UncaughtExceptionTest {
 
    public static void main(String[] args) {
        Thread tt = new Thread() {
            @Override
            public void start() {
                int[] t = new int[1];
                for (int i = 0; i &lt; 2; i++) {
                    System.out.println(t[i]);
                }
            }
        };
 
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(e);
            }
        });
 
        tt.start();
    }
}

程序结果如下：

1
2

0
java.lang.ArrayIndexOutOfBoundsException: 1

Java文件列表的方法

yutuo — Tue, 12 Jan 2010 19:24:23 +0000

　　以前写Java程序时，对于文件目录的列表，总喜欢把所有文件列表，然后一个一个地比较后缀名以及是不是文件。这两天，看《Core Jave》时，发现可以用FilenameFilter来实现。比如，看D:\下的TXT文件，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import java.io.File;
import java.io.FilenameFilter;
 
public class FilenameFilterTest {
    public static final String EXT_TXT = ".txt";
    public static void main(String[] args) {
        File dir = new File("D:\\");
        String[] filenames = dir.list(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                return file.isFile() &amp;&amp; name.toLowerCase().endsWith(EXT_TXT);
            }
        });
        for (String filename : filenames) System.out.println(filename);
    }
}

关于带分隔符文件的读取方法

yutuo — Mon, 11 Jan 2010 19:23:40 +0000

　　在系统中，经常有批量输入和输出的操作。比如以CVS输入一个文件到数据库，输出一个文件到数据库。对于这种处理，以前总喜欢用Java的字符串分割的方法来做。今天看了《Core Java2》，发现还可以用Java自带的分隔符读入方法来实现。如下文本：

1
2
3

Harry Hacker,35500,1989,10,1
Carl Crecker,75000,1987,12,15
Tony Tester,38000,1990,3,15

对于这种文件，可以使用StringTokenizer来读入。代码如下：

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

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.StringTokenizer;
 
public class StringTokenizerTest {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader("E:\\Test.txt"));
 
        while(true) {
            String data = in.readLine();
            if (data == null || data.length() == 0) break;
            System.out.println(readData(data));
        }
    }
 
    private static Employee readData(String in) {
        Employee em = new Employee();
        StringTokenizer t = new StringTokenizer(in, ",");
        em.name = t.nextToken();
        em.salary = Long.parseLong(t.nextToken());
        em.hireDay = new GregorianCalendar(Integer.parseInt(t.nextToken()), Integer.parseInt(t.nextToken()) - 1,
                Integer.parseInt(t.nextToken())).getTime();
        return em;
    }
}
 
class Employee {
    public String name;
    public long salary;
    public Date hireDay;
 
    public String toString() {
        return name + "," + salary + "," + hireDay;
    }
}

结果为：

1
2
3

Harry Hacker,35500,Sun Oct 01 00:00:00 JST 1989
Carl Crecker,75000,Tue Dec 15 00:00:00 JST 1987
Tony Tester,38000,Thu Mar 15 00:00:00 JST 1990

关于Java的编码形式

yutuo — Sun, 10 Jan 2010 19:22:50 +0000

在Java里支持各种各样的编码形式，如GB2312,UTF-8等。以下的程序可以查看Java的所有支持的编码。编码的使用主要用于文件的输入和输出。

1
2
3
4
5
6
7
8
9
10
11

import java.nio.charset.Charset;
import java.util.Map;
 
public class AvailableCharsets {
    public static void main(String[] args) {
        Map<String, Charset> charsets = Charset.availableCharsets();
        for(String name : charsets.keySet()) {
            System.out.println(charsets.get(name));
        }
    }
}

上面的程序的结果为：

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

Big5
Big5-HKSCS
EUC-JP
EUC-KR
GB18030
GB2312
GBK
IBM-Thai
IBM00858
IBM01140
IBM01141
IBM01142
IBM01143
IBM01144
IBM01145
IBM01146
IBM01147
IBM01148
IBM01149
IBM037
IBM1026
IBM1047
IBM273
IBM277
IBM278
IBM280
IBM284
IBM285
IBM297
IBM420
IBM424
IBM437
IBM500
IBM775
IBM850
IBM852
IBM855
IBM857
IBM860
IBM861
IBM862
IBM863
IBM864
IBM865
IBM866
IBM868
IBM869
IBM870
IBM871
IBM918
ISO-2022-CN
ISO-2022-JP
ISO-2022-JP-2
ISO-2022-KR
ISO-8859-1
ISO-8859-13
ISO-8859-15
ISO-8859-2
ISO-8859-3
ISO-8859-4
ISO-8859-5
ISO-8859-6
ISO-8859-7
ISO-8859-8
ISO-8859-9
JIS_X0201
JIS_X0212-1990
KOI8-R
KOI8-U
Shift_JIS
TIS-620
US-ASCII
UTF-16
UTF-16BE
UTF-16LE
UTF-32
UTF-32BE
UTF-32LE
UTF-8
windows-1250
windows-1251
windows-1252
windows-1253
windows-1254
windows-1255
windows-1256
windows-1257
windows-1258
windows-31j
x-Big5-Solaris
x-euc-jp-linux
x-EUC-TW
x-eucJP-Open
x-IBM1006
x-IBM1025
x-IBM1046
x-IBM1097
x-IBM1098
x-IBM1112
x-IBM1122
x-IBM1123
x-IBM1124
x-IBM1381
x-IBM1383
x-IBM33722
x-IBM737
x-IBM834
x-IBM856
x-IBM874
x-IBM875
x-IBM921
x-IBM922
x-IBM930
x-IBM933
x-IBM935
x-IBM937
x-IBM939
x-IBM942
x-IBM942C
x-IBM943
x-IBM943C
x-IBM948
x-IBM949
x-IBM949C
x-IBM950
x-IBM964
x-IBM970
x-ISCII91
x-ISO-2022-CN-CNS
x-ISO-2022-CN-GB
x-iso-8859-11
x-JIS0208
x-JISAutoDetect
x-Johab
x-MacArabic
x-MacCentralEurope
x-MacCroatian
x-MacCyrillic
x-MacDingbat
x-MacGreek
x-MacHebrew
x-MacIceland
x-MacRoman
x-MacRomania
x-MacSymbol
x-MacThai
x-MacTurkish
x-MacUkraine
x-MS932_0213
x-MS950-HKSCS
x-mswin-936
x-PCK
x-SJIS_0213
x-UTF-16LE-BOM
X-UTF-32BE-BOM
X-UTF-32LE-BOM
x-windows-50220
x-windows-50221
x-windows-874
x-windows-949
x-windows-950
x-windows-iso2022jp