package com.test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PatternTest {
 
 private static void test0() {
  String str = "<biao><>c<b>x";
  Pattern pattern;
  Matcher matcher;
  // 贪婪: 最长匹配 .* : 输出: <biao><>c<b>
  pattern = Pattern.compile("<.*>");
  matcher = pattern.matcher(str);
  while (matcher.find()) {
  System.out.println(matcher.group());
  }
  // 不知是否非贪婪 .*? : 输出: <biao>, <>, <b>
  pattern = Pattern.compile("<.*?>");
  matcher = pattern.matcher(str);
  while (matcher.find()) {
  System.out.println(matcher.group());
  }
  // 使用组, 输出<>里的内容, 输出: 'biao', ' ', 'b'
  // 0组代表整个表达式, 子组从1开始
  pattern = Pattern.compile("<(.*?)>");
  matcher = pattern.matcher(str);
  while (matcher.find()) {
  System.out.println(">>"+matcher.group(1));
  }
 }
 
 /** 查找以Java开头的任意字符串 */
 public static void test1() {
  Pattern pattern = Pattern.compile("^Java.*");
  Matcher m = pattern.matcher("Java哈哈");
  System.out.println(m.find());
 }
 
 /** 以多条件分割字符串 */
 public static void test2() {
  Pattern pattern = Pattern.compile("[,|\\+]+");
  String str[] = pattern.split("Java+ Hello World  Java,Hello,,World|Sun");
  if(str != null) {
   for(String s : str) {
    System.out.println(">> " +s);
   }
  }
 }

 /** 文字替换 */
 public static void test3() {
  Pattern pattern = Pattern.compile("abc*");
  Matcher matcher = pattern.matcher("xabcccc测试abd, abcce");
  String str = matcher.replaceAll("(?)");
  System.out.println(str);
 }
 
 /** 文字替换(替换字符)  结果将会是  x(?)测试(?)d, (?) */
 public static void test4() {
  Pattern pattern = Pattern.compile("123|4(567)");
  Matcher matcher = pattern.matcher("0123456789abcde");
  StringBuffer sb = new StringBuffer();
  while(matcher.find()) {
   System.out.println(matcher.group(0));
   System.out.println(matcher.group(1));
   System.out.println(">>"+ matcher.start()+":"+matcher.end());
   matcher.appendReplacement(sb, "(?)");
  }
  matcher.appendTail(sb);
  System.out.println(sb);
 }
 
 public static void test5() {
  String regEx="B(ond)";
       
        String str="My name is Bond. James Bond.";
        
        Pattern p=Pattern.compile(regEx);
        
        Matcher matcher=p.matcher(str);
        
        if(matcher.find()){
            System.out.println(matcher.groupCount());
            System.out.println(matcher.start());
            String group_0 = matcher.group(0);
            String group_1 = matcher.group(1);
            System.out.println("Group 0 " + group_0);
            System.out.println("Group 1 " + group_1);
            System.out.println(str);
        }

 }
 
 // 验证是否为邮箱地址
 public static void test6() {
  String str="ponline@yahoo.com.cn.jcWe--_*";
  Pattern pattern =
  Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+");
  Matcher matcher = pattern.matcher(str);
  System.out.println(matcher.matches());
 }
 
 /** 去除html 标记  */
 public static void test7() {
  Pattern pattern = Pattern.compile(".+?");
  Matcher matcher = pattern.matcher("<a 测试 href=\"index.html\">主页</a>");
  matcher.find();
  System.out.println(matcher.group());
  String string = matcher.replaceFirst("");
  System.out.println(string);
 }
 
 /** 查找html 中对应条件字符串 **/
 public static void test8() {
  Pattern pattern = Pattern.compile("href=\"(.+?)\"");
  Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>");
  if(matcher.find())
    System.out.println(matcher.group(1));
 }
 /** 截取http://地址  **/
 public static void test9() {
  Pattern pattern = Pattern.compile("(http://|https://){1}.+");
  Matcher matcher = pattern.matcher("dsdsds<http://dfhf.\\sd-: s//国家gfg-ffdfd>fdf");
  StringBuffer buffer = new StringBuffer();
  while(matcher.find()){              
      buffer.append(matcher.group());        
      buffer.append("\r\n"); 
      System.out.println(buffer.toString());
  }
 }
 
 /** 替换指定{}中文字  **/
 public static void test10() {
  String str = "Java目前的发展史是由{0}年-{1}年";
  String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}};
  System.out.println(replace(str,object));
 }
 
 public static String replace(String sourceString, String[][] object) {
  String temp=sourceString;    
        for(int i=0;i<object.length;i++){
           String[] result=(String[])object[i];
           Pattern    pattern = Pattern.compile(result[0]);
           Matcher matcher = pattern.matcher(temp);
           temp=matcher.replaceAll(result[1]);
        }
        return temp;
 }
 
 public static void main(String[] args) throws Exception{
  PatternTest.test10();
 

 }
}

Here’s a guide to show you how to integrate Spring with JAX-WS, as mention in this link : http://jax-ws-commons.java.net/spring/. Upon finishing this tutorial, you will create a simple HelloWorld web service (JAX-WS), and DI a bean into the web service via Spring.

1. Project Folder

See the final project folder structure.

2. Project Dependencies

Use Maven to get all the library dependencies. The key to integrate Spring with JAX-WS is via jaxws-spring.jar.

File : pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0    http://maven.apache.org/maven-v4_0_0.xsd">   <modelVersion>4.0.0</modelVersion>   <groupId>com.mkyong</groupId>   <artifactId>WebServicesExample</artifactId>   <packaging>war</packaging>   <version>1.0-SNAPSHOT</version>   <name>WebServicesExample Maven Webapp</name>   <url>http://maven.apache.org</url>     <repositories>     <repository>       <id>java.net</id>       <url>http://download.java.net/maven/2</url>     </repository>   </repositories>     <dependencies>           <dependency>                 <groupId>junit</groupId>                 <artifactId>junit</artifactId>                 <version>3.8.1</version>                 <scope>test</scope>         </dependency>   	<!-- Spring framework -->  	<dependency> 		<groupId>org.springframework</groupId> 		<artifactId>spring</artifactId> 		<version>2.5.6</version> 	</dependency>           <!-- JAX-WS -->  	<dependency> 	  	<groupId>com.sun.xml.ws</groupId> 	        <artifactId>jaxws-rt</artifactId> 	        <version>2.2.3</version> 	</dependency>    	<!-- Library from java.net, integrate Spring with JAX-WS -->  	<dependency> 		<groupId>org.jvnet.jax-ws-commons.spring</groupId> 		<artifactId>jaxws-spring</artifactId> 		<version>1.8</version> 		<exclusions> 		  <exclusion>            		<groupId>org.springframework</groupId>       			<artifactId>spring-core</artifactId>         	  </exclusion>         	  <exclusion>            		<groupId>org.springframework</groupId>       			<artifactId>spring-context</artifactId>         	  </exclusion>         	  <exclusion>            		<groupId>com.sun.xml.stream.buffer</groupId>       			<artifactId>streambuffer</artifactId>         	  </exclusion>         	  <exclusion>            		<groupId>org.jvnet.staxex</groupId>       			<artifactId>stax-ex</artifactId>         	  </exclusion> 		</exclusions> 	</dependency>     </dependencies>   <build>     <finalName>web services</finalName>     <plugins>        <plugin>            <groupId>org.apache.maven.plugins</groupId>            <artifactId>maven-compiler-plugin</artifactId>            <version>2.3.1</version>            <configuration>                <source>1.6</source>                <target>1.6</target>            </configuration>        </plugin>     </plugins>   </build> </project>

3. JAX-WS Hello World

A simple JAX-WS example, and dependency inject (DI) “HelloWorldBo” via Spring.

File : HelloWorldWS.java

package com.mkyong.ws;   import javax.jws.WebMethod; import javax.jws.WebService;   import com.mkyong.bo.HelloWorldBo;   @WebService public class HelloWorldWS{   	//DI via Spring 	HelloWorldBo helloWorldBo;   	@WebMethod(exclude=true) 	public void setHelloWorldBo(HelloWorldBo helloWorldBo) { 		this.helloWorldBo = helloWorldBo; 	}   	@WebMethod(operationName="getHelloWorld") 	public String getHelloWorld() {   		return helloWorldBo.getHelloWorld();   	}   }

4. Beans

Here’s the HelloWorldBo class, with a getHelloWorld() method to return a simple string.

File : HelloWorldBo.java

package com.mkyong.bo;   public interface HelloWorldBo{   	String getHelloWorld();   }

File : HelloWorldBoImpl.java

package com.mkyong.bo.impl;   import com.mkyong.bo.HelloWorldBo;   public class HelloWorldBoImpl implements HelloWorldBo{   	public String getHelloWorld(){ 		return "JAX-WS + Spring!"; 	}   }

5. Spring Beans Configuration

Spring beans configuration file to bind URL pattern “/hello” to “com.mkyong.ws.HelloWorldWS” web service class.

File : applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns:ws="http://jax-ws.dev.java.net/spring/core"        xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"        xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd        http://jax-ws.dev.java.net/spring/core         http://jax-ws.dev.java.net/spring/core.xsd         http://jax-ws.dev.java.net/spring/servlet         http://jax-ws.dev.java.net/spring/servlet.xsd" >       <wss:binding url="/hello">         <wss:service>             <ws:service bean="#helloWs"/>         </wss:service>     </wss:binding>       <!-- Web service methods -->     <bean id="helloWs" class="com.mkyong.ws.HelloWorldWS">     	<property name="helloWorldBo" ref="HelloWorldBo" />     </bean>       <bean id="HelloWorldBo" class="com.mkyong.bo.impl.HelloWorldBoImpl" />   </beans>

6. web.xml

In web.xml, declares “com.sun.xml.ws.transport.http.servlet.WSSpringServlet“, and link it to “/hello“.

<web-app id="WebApp_ID" 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">   	<display-name>Spring + JAX-WS</display-name>   	<servlet>     	        <servlet-name>jaxws-servlet</servlet-name>     	       <servlet-class>     		          com.sun.xml.ws.transport.http.servlet.WSSpringServlet     	        </servlet-class>   	</servlet>   	<servlet-mapping>                 <servlet-name>jaxws-servlet</servlet-name>                 <url-pattern>/hello</url-pattern>          </servlet-mapping>            <!-- Register Spring Listener -->   	<listener>     	        <listener-class>     		     org.springframework.web.context.ContextLoaderListener     	        </listener-class>   	</listener>   </web-app>

7. Demo

Start the project, and access the deployed web service via URL “/hello“, for example http://localhost:8080/WebServicesExample/hello?wsdl

去这里下载jdic

https://jdic.dev.java.net/

我用的是0.94版,eclipse 3.x

下截后

将jdic.dll,IeEmbed.exe,jdic.jar,MozEmbed.exe,packager.jar,tray.dll考贝到你的工程lib目录(在工程上建立lib目录),然后设置以上.jar文件到编译路径.

建一个jFrame,加一个JPanel

以下为代码片断, 用以下代码加载浏览器

              WebBrowser webBrowser = new WebBrowser();

              panel_name.add(webBrowser, BorderLayout.CENTER);

              webBrowser .setURL(new URL(http://www.google.com));

              webBrowser .addWebBrowserListener(new WebBrowserListener() {
         
            public void downloadStarted(WebBrowserEvent event) {;}
            public void downloadCompleted(WebBrowserEvent event) {;}
            public void downloadProgress(WebBrowserEvent event) {;}
            public void downloadError(WebBrowserEvent event) {;}

            public void documentCompleted(WebBrowserEvent event) {

                      //在这里写代码

                     // 很COOL的功能,与脚本交互

                    StringBuffer jsBuff = new StringBuffer();

                    jsBuff.append(" var bodyhtml = document.body.innerHTML;");   //取当前页的内容

                    String html =     webBrowser .getContent();  //取当前页的内容,这个不好用,在有iframe的网页中不灵

            }

          public void titleChange(WebBrowserEvent event) {;} 
            public void statusTextChange(WebBrowserEvent event) {;}
           public void windowClose(WebBrowserEvent arg0) {
           }
           });

    // 创建Excel工作表
    jxl.write.WritableSheet ws = wwb.createSheet("个人信息表1", 0);
    /**
     * 19列,标题占据2行
     */
    int charTitle = 10;// 标题字体大小
    int charNormal = 10;// 标题字体大小
    // 添加带有字型Formatting的对象

    // 用于标题
    jxl.write.WritableFont titleFont = new jxl.write.WritableFont(
      WritableFont.createFont("宋体"), charTitle, WritableFont.BOLD);

    jxl.write.WritableCellFormat titleFormat = new jxl.write.WritableCellFormat(
      titleFont);
    titleFormat.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
    titleFormat.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
    titleFormat.setAlignment(Alignment.CENTRE); // 水平对齐
    titleFormat.setWrap(true); // 是否换行
    titleFormat.setBackground(Colour.GRAY_25);// 背景色暗灰-25%
    // 用于正文
    WritableFont normalFont = new WritableFont(WritableFont
      .createFont("宋体"), charNormal);
    jxl.write.WritableCellFormat normalFormat = new jxl.write.WritableCellFormat(
      normalFont);
    normalFormat.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
    normalFormat.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
    normalFormat.setAlignment(Alignment.CENTRE);// 水平对齐
    normalFormat.setWrap(true); // 是否换行

    // 用于带有formatting的Number对象
    WritableFont nf = new WritableFont(WritableFont
      .createFont("Times New Roman"), charNormal);
    // jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##");
    jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(
      nf);
    wcfN.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
    wcfN.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
    wcfN.setAlignment(Alignment.CENTRE);// 水平对齐
    wcfN.setWrap(true); // 是否换行
    /**
     * 添加标题
     */
    // 第一行
    /** *********设置列宽每个字体占charset个**************** */
    ws.mergeCells(14, 0, 18, 0); // 合并单元格，
    ws.mergeCells(10, 0, 13, 0); // 合并单元格，

    ws.mergeCells(0, 0, 0, 1); // 合并单元格，序号
    ws.setColumnView(0, 6); // 设置列宽,第1列
    ws.mergeCells(1, 0, 1, 1); // 合并单元格，公民身份证号
    ws.setColumnView(1, 9); // 设置列宽,第2列
    ws.mergeCells(2, 0, 2, 1); // 合并单元格，电脑序号
    ws.setColumnView(2, 6); // 设置列宽,第3列
    ws.mergeCells(3, 0, 3, 1); // 合并单元格，四险姓名
    ws.setColumnView(3, 6); // 设置列宽,第4列
    ws.mergeCells(4, 0, 4, 1); // 合并单元格，医疗姓名
    ws.setColumnView(4, 6); // 设置列宽,第5列
    ws.mergeCells(5, 0, 5, 1); // 合并单元格，医疗保险手册号
    ws.setColumnView(5, 9); // 设置列宽,第6列
    ws.mergeCells(6, 0, 6, 1); // 合并单元格，四险缴费人员类别
    ws.setColumnView(6, 9); // 设置列宽,第7列
    ws.mergeCells(7, 0, 7, 1); // 合并单元格，医疗缴费人员类别
    ws.setColumnView(7, 9); // 设置列宽,第8列
    ws.mergeCells(8, 0, 8, 1); // 合并单元格，医疗参保人员类别
    ws.setColumnView(8, 9); // 设置列宽,第9列
    ws.mergeCells(9, 0, 9, 1); // 合并单元格，医疗参保状态
    ws.setColumnView(9, 7); // 设置列宽,第10列
    ws.setColumnView(10, 6); // 设置列宽,第11列
    ws.setColumnView(11, 6); // 设置列宽,第12列
    ws.setColumnView(12, 6); // 设置列宽,第13列
    ws.setColumnView(13, 6); // 设置列宽,第14列
    ws.setColumnView(14, 6); // 设置列宽,第15列
    ws.setColumnView(15, 6); // 设置列宽,第16列
    ws.setColumnView(16, 6); // 设置列宽,第17列
    ws.setColumnView(17, 6); // 设置列宽,第18列
    ws.setColumnView(18, 6); // 设置列宽,第19列
    jxl.write.Label tit00 = new jxl.write.Label(0, 0, "序号", titleFormat);
    ws.addCell(tit00);
    jxl.write.Label tit10 = new jxl.write.Label(1, 0, "公民身份证号",
      titleFormat);
    ws.addCell(tit10);
    jxl.write.Label tit20 = new jxl.write.Label(2, 0, "电脑序号",
      titleFormat);
    ws.addCell(tit20);
    jxl.write.Label tit30 = new jxl.write.Label(3, 0, "四险姓名",
      titleFormat);
    ws.addCell(tit30);
    jxl.write.Label tit40 = new jxl.write.Label(4, 0, "医疗姓名",
      titleFormat);
    ws.addCell(tit40);
    jxl.write.Label tit50 = new jxl.write.Label(5, 0, "医疗保险手册号",
      titleFormat);
    ws.addCell(tit50);
    jxl.write.Label tit60 = new jxl.write.Label(6, 0, "四险缴费人员类别",
      titleFormat);
    ws.addCell(tit60);
    jxl.write.Label tit70 = new jxl.write.Label(7, 0, "医疗缴费人员类别",
      titleFormat);
    ws.addCell(tit70);
    jxl.write.Label tit80 = new jxl.write.Label(8, 0, "医疗参保人员类别",
      titleFormat);
    ws.addCell(tit80);
    jxl.write.Label tit90 = new jxl.write.Label(9, 0, "医疗参保状态",
      titleFormat);
    ws.addCell(tit90);
    jxl.write.Label tit100 = new jxl.write.Label(10, 0, "四险缴费状态",
      titleFormat);
    ws.addCell(tit100);
    jxl.write.Label tit140 = new jxl.write.Label(14, 0, "缴费基数",
      titleFormat);
    ws.addCell(tit140);
    // 第二行
    jxl.write.Label tit101 = new jxl.write.Label(10, 1, "养老",
      titleFormat);
    ws.addCell(tit101);
    jxl.write.Label tit111 = new jxl.write.Label(11, 1, "失业",
      titleFormat);
    ws.addCell(tit111);
    jxl.write.Label tit121 = new jxl.write.Label(12, 1, "工伤",
      titleFormat);
    ws.addCell(tit121);
    jxl.write.Label tit131 = new jxl.write.Label(13, 1, "生育",
      titleFormat);
    ws.addCell(tit131);
    jxl.write.Label tit141 = new jxl.write.Label(14, 1, "养老",
      titleFormat);
    ws.addCell(tit141);
    jxl.write.Label tit151 = new jxl.write.Label(15, 1, "失业",
      titleFormat);
    ws.addCell(tit151);
    jxl.write.Label tit161 = new jxl.write.Label(16, 1, "工伤",
      titleFormat);
    ws.addCell(tit161);
    jxl.write.Label tit171 = new jxl.write.Label(17, 1, "生育",
      titleFormat);
    ws.addCell(tit171);
    jxl.write.Label tit181 = new jxl.write.Label(18, 1, "医疗",
      titleFormat);
    ws.addCell(tit181);

    double yljs = 0;// 医疗基数合计
    double yxjs = 0;// 养老基数合计
    double syjs = 0;// 失业基数合计
    double sxjs = 0;// 生育基数合计
    double gsjs = 0;// 工伤基数合计
    for (int i = 0; i < list.size(); i++) {
     Grxx xx = (Grxx) list.get(i);
     jxl.write.Label lab1 = new jxl.write.Label(0, i + 2, String
       .valueOf(i + 1), wcfN);
     ws.addCell(lab1);// 第1列：序号
     jxl.write.Label lab2 = new jxl.write.Label(1, i + 2, xx
       .getBzhm(), wcfN);
     ws.addCell(lab2);// 第2列：公民身份证号
     jxl.write.Label lab3 = new jxl.write.Label(2, i + 2, "字段不存在",
       wcfN);
     ws.addCell(lab3);// 第3列：电脑序号
     jxl.write.Label lab4 = new jxl.write.Label(3, i + 2,
       xx.getXm(), normalFormat);
     ws.addCell(lab4);// 第4列：四险姓名
     jxl.write.Label lab5 = new jxl.write.Label(4, i + 2,
       xx.getXm(), normalFormat);
     ws.addCell(lab5);// 第5列：医疗姓名
     jxl.write.Label lab6 = new jxl.write.Label(5, i + 2, xx
       .getBxh(), wcfN);
     ws.addCell(lab6);// 第6列：医疗保险手册号
     jxl.write.Label lab7 = new jxl.write.Label(6, i + 2, xx
       .getBxh(), normalFormat);
     ws.addCell(lab7);// 第7列：四险缴费人员类别
     jxl.write.Label lab8 = new jxl.write.Label(7, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab8);// 第8列：医疗缴费人员类别
     jxl.write.Label lab9 = new jxl.write.Label(8, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab9);// 第9列：医疗参保人员类别
     jxl.write.Label lab10 = new jxl.write.Label(9, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab10);// 第10列：医疗参保状态
     jxl.write.Label lab11 = new jxl.write.Label(10, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab11);// 第11列：养老缴费状态
     jxl.write.Label lab12 = new jxl.write.Label(11, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab12);// 第12列：失业缴费状态
     jxl.write.Label lab13 = new jxl.write.Label(12, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab13);// 第13列：工伤缴费状态
     jxl.write.Label lab14 = new jxl.write.Label(13, i + 2, "字段不存在",
       normalFormat);
     ws.addCell(lab14);// 第14列：生育缴费状态
     jxl.write.Number lab15 = new jxl.write.Number(14, i + 2, xx
       .getGrjs().getYxjfjs().doubleValue(), wcfN);
     ws.addCell(lab15);// 第15列：养老缴费基数
     yxjs += xx.getGrjs().getYxjfjs().doubleValue();
     jxl.write.Number lab16 = new jxl.write.Number(15, i + 2, xx
       .getGrjs().getSyjfjs().doubleValue(), wcfN);
     ws.addCell(lab16);// 第16列：失业缴费基数
     syjs += xx.getGrjs().getSyjfjs().doubleValue();
     jxl.write.Number lab17 = new jxl.write.Number(16, i + 2, xx
       .getGrjs().getGsjfjs().doubleValue(), wcfN);
     ws.addCell(lab17);// 第17列：工伤缴费基数
     gsjs += xx.getGrjs().getGsjfjs().doubleValue();
     jxl.write.Number lab18 = new jxl.write.Number(17, i + 2, xx
       .getGrjs().getSxjfjs().doubleValue(), wcfN);
     ws.addCell(lab18);// 第18列：生育缴费基数
     sxjs += xx.getGrjs().getSxjfjs().doubleValue();
     jxl.write.Number lab19 = new jxl.write.Number(18, i + 2, xx
       .getGrjs().getYljfjs().doubleValue(), wcfN);
     ws.addCell(lab19);// 第19列：医疗缴费基数
     yljs += xx.getGrjs().getYljfjs().doubleValue();
    }
    /**
     * 最后一行合计
     */
    int end = list.size() + 2;
    jxl.write.Label end0 = new jxl.write.Label(0, end, "合计",
      normalFormat);
    ws.addCell(end0);
    jxl.write.Label end1 = new jxl.write.Label(1, end, "--",
      normalFormat);
    ws.addCell(end1);
    jxl.write.Label end2 = new jxl.write.Label(2, end, "--",
      normalFormat);
    ws.addCell(end2);
    jxl.write.Label end3 = new jxl.write.Label(3, end, "--",
      normalFormat);
    ws.addCell(end3);
    jxl.write.Label end4 = new jxl.write.Label(4, end, "--",
      normalFormat);
    ws.addCell(end4);
    jxl.write.Label end5 = new jxl.write.Label(5, end, "--",
      normalFormat);
    ws.addCell(end5);
    jxl.write.Label end6 = new jxl.write.Label(6, end, "--",
      normalFormat);
    ws.addCell(end6);
    jxl.write.Label end7 = new jxl.write.Label(7, end, "--",
      normalFormat);
    ws.addCell(end7);
    jxl.write.Label end8 = new jxl.write.Label(8, end, "--",
      normalFormat);
    ws.addCell(end8);
    jxl.write.Label end9 = new jxl.write.Label(9, end, "--",
      normalFormat);
    ws.addCell(end9);
    jxl.write.Label end10 = new jxl.write.Label(10, end, "--",
      normalFormat);
    ws.addCell(end10);
    jxl.write.Label end11 = new jxl.write.Label(11, end, "--",
      normalFormat);
    ws.addCell(end11);
    jxl.write.Label end12 = new jxl.write.Label(12, end, "--",
      normalFormat);
    ws.addCell(end12);
    jxl.write.Label end13 = new jxl.write.Label(13, end, "--",
      normalFormat);
    ws.addCell(end13);
    // 养老
    jxl.write.Number end14 = new jxl.write.Number(14, end, yxjs, wcfN);
    ws.addCell(end14);
    // 失业
    jxl.write.Number end15 = new jxl.write.Number(15, end, syjs, wcfN);
    ws.addCell(end15);
    // 工伤
    jxl.write.Number end16 = new jxl.write.Number(16, end, gsjs, wcfN);
    ws.addCell(end16);
    // 生育
    jxl.write.Number end17 = new jxl.write.Number(17, end, sxjs, wcfN);
    ws.addCell(end17);
    // 医疗
    jxl.write.Number end18 = new jxl.write.Number(18, end, yljs, wcfN);
    ws.addCell(end18);
    // 写入Exel工作表
    wwb.write();
    // 关闭Excel工作薄对象
    wwb.close();
    os.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
}

这一连接，发现WebMail只支持pop3/imap/smtp的protocol，而对gmail的pop3 ssl/imap ssl/smtp ssl的安全连接都不支持，于是奋力去修改，终于今天搞定了。

接着为了测试邮件的多样性，从Hotmail账户当中转移了一部分邮件进入gmail的IMAP Folder，发现英国金融时报旗下的FT中文网发送的新闻邮件，居然无法在WebMail中显示，出现Exception.

java.io.IOException: Unknown encoding: GB2312
at javax.mail.internet.MimePartDataSource.getInputStream(MimePartDataSource.java:108)
at com.sun.mail.handlers.text_plain.getContent(text_plain.java:90)
at javax.activation.DataSourceDataContentHandler.getContent(DataHandler.java:775)
at javax.activation.DataHandler.getContent(DataHandler.java:522)
at javax.mail.internet.MimeMessage.getContent(MimeMessage.java:1395)

觉得很奇怪，GB2312肯定属于Java认识的encoding啊？ 为什么会出这种信息呢？ 仔细检查此邮件的源码，以及查阅资料。发现此处所说的Encoding并非是Java Encoding。 而是邮件的一种自有的编码。 该新闻邮件的编码

Date: Thu, 20 Aug 2009 09:09:16 +0800
MIME-Version: 1.0
Content-Type: text/html; charset=”gb2312″
Content-Transfer-Encoding: gb2312
Message-ID: 1250730614939471@200809NewsLetter

该邮件的发送程序把 text/html charset=gb2312的编码部分，当作Content-Transfer-Encoding的编码，而实际上JavaMail认识的Content-Transfer-Encoding包含如下几种：”base64″, “quoted-printable”, “7bit”, “8bit”, “binary”, “uuencode”。

原则上针对这种错误格式的邮件，可以不对应，但是考虑到未来可能还有别的问题，于是直接去修改 javax.mail.internet.MimePartDataSource.java，

public InputStream getInputStream() throws IOException {
InputStream is;

try {
if (part instanceof MimeBodyPart)
is = ((MimeBodyPart)part).getContentStream();
else if (part instanceof MimeMessage)
is = ((MimeMessage)part).getContentStream();
else
throw new MessagingException(“Unknown part”);
String encoding = restrictEncoding(part.getEncoding(), part);
if (encoding != null){
if(encoding.equalsIgnoreCase(“GB2312″) ||
encoding.equalsIgnoreCase(“GBK”)){
encoding = “7bit”;
}
return MimeUtility.decode(is, encoding);
}else{
return is;
}
} catch (MessagingException mex) {
throw new IOException(mex.getMessage());
}
}

编译好以后，放回 sun-javamail-1.4.2.jar，执行一遍后，OK了。

如果已经配置好CATALINA_HOME,以及path变量%CATALINA_HOME%\bin,可直接运行下列命令。
C:\> service.bat install                                               C:\> service.bat   remove
没有配置环境变量则进入tomcat安装目录下的bin目录，加载服务service install tomcat6  卸载服务service remove tomcat6

二、apache服务安装卸载
把apache注册为windows服务. 运行cmd命令 注册apache为windows服务：apache安装目录\bin\httpd.exe -k install 卸载apache为windows服务：apache安装目录\bin\httpd.exe -k uninstall

三、MYSQL服务安装卸载

1.、 安装服务。 
在Windows2000下，安装完成后，并没有把MySQL安装成服务，我们必须执行下面的语句把MySQL注册为服务:mysql安装目录\bin\mysqld-nt  –-install。 
Windows98下没有服务的概念，所以不用安装服务。  

2、 卸载服务 
可以通过下面的命令卸载MySQL服务:mysql安装目录\bin\mysqld-nt  –-remove。 
经过上面的安装就可以使用了，可以把我们系统空的数据库内建到mySQL数据目录即可，缺省数据库目录在installdirmysqldata。 

3.、 启动服务 
在Windows2000下，安装服务后可以启动MySQL服务:net start mysql。 
在Windows98下，可以用下面的命令启动服务:c:\mysql\bin\mysqld，服务启动后在后台运行，并没有界面。 
4.、 停止服务 
在Windows2000下，可以通过下面的命令停止MySQL服务:net stop mysql。 
在Windows98下，可以通过下面命令停止服务:C:> C:\mysql\bin\mysqladmin -u root shutdown 


==========================================================================
1.报错:Can't find messagefile 'F:Program Filesmysqlshareenglisherrmsg.sys' 
原因:原来的4.1版本安装在F:Program Filesmysql目录;而现在的5.0版本在F:database目录 
解决方法:在c:winnt目录下找到my.ini文件，修改或删除之 

2.报错:ready for connections. 
Version: '5.0.21-community-nt' socket: '' port: 3306 MySQL Community Edition (GPL) 
原因:socket为空，没有配置mysql;或者端口已经占用 
解决方法: mysqlbin目录下运行MySQLInstanceConfig.exe配置mysql实例 

3.如何更改Win2000服务MySQL属性中的可执行文件路径! 
开始时在D盘装了MySQL，后来卸载后，格式化D盘，再次安装，路径与原路径不同，不能通过“net start mysql”启动。查看win2000服务中MYsql的属性，可执行文件路径在位于D盘。现在怎么样更改，或启动Mysql? 
注册表里HKEY_LOCAL_MECHINE---SYSTEM ---CurrentControlSet里 


启动MYSQL服务时出错的几种解决方法 
1.安装MYSQL后更改了ROOT的密码后用net startmysql启动时我就遇到了这样的问题.使用以下命令后c:mysqlbinmysqladmin-u root -p shutdown再net start mysql就没有这个错误提示了! 

2.MySQL的1067错误 
Q:我的Mysql碰到了 1067 错误 
错误信息为: 
A:在我的机上的解决办法是: 
修改%windir%my.ini，增加 
3.已经弄好了!!! 
好像是这样…… 
mysql_install_db脚本只是在初次安装时才需要运行一次,之后就不用再运行了,不知道是不是这么回事.我把mysql.server拷贝至/etc/rc.d/init.d/中,运行chkconfig mysql.server,至此mysql服务器每次开机自动启动,只要设置好PATH,在命令行上输入mysql就一切搞定! 

基于服务模式的参数调整
      基于服务模式修改tomcat\bin目录下的catalina.bat文件，调整参数（如：内存）是不起作用的，我们可以采用以下方式(以tomcat5为例)：
1、运行cmd，从控制台进入tomcat的bin目录
2、运行tomcat5w //MS//服务名，windows的右下角出现托盘图标
   （服务名是具体的tomcat服务）
3、进入调整参数，保存
4、重新启动tomcat服务

试图在jsp页面里包含Action：

<c:import url="/friendlink.do?method=list"></c:import>
<jsp:include flush="true" page="friendlink.do"></jsp:include>

结果出现以上错误。

想想其实也很容易理解，Action的过程本身就是请求转发，而此时处理未完成页面却已输出。

解决办法一：使用bean:include

<bean:include id="friendlink" page="/friendlink.do?method=list"/>

<bean:write name="friendlink" filter="false"/>

可以这样理解，就是Action处理的结果被保存到bean里了，这里只是输出bean里包含的内容，没有涉及页面转发和定向问题，所以不会有异常。

解决办法二：使用tiles

tiles里可以直接包含Action，配置方法和包含jsp时一样。

解决办法三：使用Ajax

Ajax就是被设计来从后台异步发送请求和接收处理结果，所以必定能满足这种需求。

解决办法四：使用TAG

标签的用法就不用说了，相当于不用Action而在页面嵌入Java代码。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/prufeng/archive/2009/05/24/4213218.aspx

1. byte[] data;   
2. InputStream is = new ByteArrayInputStream(data);  

JDOM 是一种使用 XML 的独特 Java 工具包，用于快速开发 XML 应用程序。它的设计包含 Java 语言的语法乃至语义。但是它是否比现有的 -- 更标准的 -- XML APL 好呢？当我们看过一些示例并说明这个流行的开放源代码项目的设计目标后，您自己来判断吧。最近这个开放源代码项目已被正式接受成为 Java 规范要求。

作为开发人员，您可能听说过 80-20 规则，在其它领域被称为 Pareto 法则：一种过程或方法能适应所有可能情况的 80%，另外的 20% 则需要根据具体情况来处理。软件开发的必然结果是：对于开发人员而言，有了给定的技术后就能非常容易地完成可能要做的工作的 80%。

当然，软件产品和标准并不总是根据 80-20 规则发展的。特别的，Java XML 的缺陷就是这条规则的一个例外。Java 的编程世界拥有很多的 API -- 一些是自己开发的，一些是由几个大公司开发并被制定为标准的 -- 他们提供了解决特殊 XML 任务的成熟解决方案。作为 XML 普遍性的证明，每个新任务都存在着一种新技术，但如何将它们结合在一起，又如何寻找一种合适的工具去完成必须重复做的任务中的 80% -- 利用 Java 语言的直观映象的基本 XML 树操作？JDOM 正好是用来解决上述问题的一个 XML API。

标记：Java 和 XML

在许多方面，Java 语言已变成供 XML 选择的一种编程语言。由于 Apache 软件基金会和 IBM alphaWorks 所做的开创性工作，现在已有完整的工具链用于创建，操作，传送文档和对 XML 文档进行语法分析。

但是，虽然许多 Java 开发人员每天都在使用 XML，Sun 却在将 XML 整合进 Java 平台方面落后了。因为在 XML 成为从商家对商家集成到 Web 站点内容流水化等方面的关键技术之前，Java 2 平台就已经非常流行了。Sun 已经使用 JSR 过程使之成为现存 XML API 的鼻祖，这一点已被广泛接受。目前最显著的是加入了 JAXP （用于 XML 语法分析的 Java API），其中包含了三个软件包：

• org.w3c.dom ，W3C 推荐的用于 XML 标准规划文档对象模型的 Java 工具
• org.xml.sax ，用于对 XML 进行语法分析的事件驱动的简单 API
• javax.xml.parsers ，工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具

尽管对于 Java 开发人员而言，有了这些软件包是件好事，但它仅仅代表获得了现有 API 标准的正式许可而已，并没有在提供一流的 Java-XML 互操作性方面取得了巨大飞跃。核心 Java 平台所缺乏的是将 XML 文档作为 Java 对象操作的直观接口。

进入 JDOM。JDOM 是两位著名的 Java 开发人员兼作者，Brett Mclaughlin 和 Jason Hunter 的创作成果， 2000 年初在类似于 Apache 协议的许可下，JDOM 作为一个开放源代码项目正式开始研发，JDOM 作为一个开放源代码项目正式开始了。它已成长为包含来自广泛的 Java 开发人员的投稿、集中反馈及错误修复的系统，并致力于建立一个完整的基于 Java 平台的解决方案，通过 Java 代码来访问、操作并输出 XML 数据。

回页首

这是 JDOM 适合的 API、哑元

JDOM 能够替换 org.w3c.dom 软件包来有计划地操作 XML 文档。它并不是一个简单的替代品，实际上 JDOM 和 DOM 能够愉快地并存。另外，尽管它提供的类的封装从配置和运行分析器执行中分担了大量工作，但它不负责根据文本输入来对 XML 进行语法分析。JDOM 建立在现有的 API 的能力之上，正如项目网页所表述的“一个更好的捕鼠器”。

要理解需要备用 API 的原因，就要考虑 W3C DOM 设计的局限性：

• 语言独立。DOM 并不是用人们心目中的 Java 语言设计的。虽然这种方法保留了在不同语言中非常相似的 API，它也使那些习惯 Java 语言的程序员感到更麻烦。例如：Java 语言内建了一种 String 类，而 DOM 则规范定义了自己的 Text 类。
  
• 严格的层次结构。DOM API 直接沿袭了 XML 规范。在 XML 中，每件东西都是一个结点，因此您能在 DOM 中找到一个几乎每件东西都可以扩展的基于 Node 的接口和返回 Node 的一系列方法。就多态性的观点来讲，它是优秀的，但鉴于如上解释，它在 Java 语言中的应用是困难而且不便的，其中从 Node 向叶类型作显式下拉会导致代码的冗长和难以理解。
  
• 接口驱动。公共 DOM API 仅由接口组成（ Exception 类是一个例外，但恰恰足够了）。w3c 对提供实现并不感兴趣，它只对定义接口（比较有意义）感兴趣。但它也意味着作为 Java 程序员使用 API 在创建 XML 对象时增加了分散程度，因为 w3c 标准大量使用工厂化的类和类似的灵活的但不直接的模式。在某些应用中，XML 文档是仅由语法分析器建立的，而从不会由应用程序级代码建立，这是不相关的。但是，随着 XML 更广泛的使用，并不是所有问题都继续需要由语法分析器来驱动。应用程序的开发人员需要一个更方便的方法有计划地构造 XML 对象。

对于程序员，这些约束意味着庞大（在内存占用和接口大小方面）的和难掌握的 API，学习和使用都很难。相反，JDOM 是作为一种轻量级 API 被制定的，最主要的是它是以 Java 为中心的。它在遵循 DOM 主要规则的基础上除去了上述缺点：

• JDOM 是 Java 平台专用的。只要有可能，API 都使用 Java 语言的内建 String 支持，因此文本值也适用于 String 。它还可利用 Java 2 平台的类集，如 List 和 Iterator ，给程序员提供了一个丰富的并且和 Java 语言类似的环境。
  
• 没有层次性。在 JDOM 中，XML 元素就是 Element 的实例，XML 属性就是 Attribute 的实例，XML 文档本身就是 Document 的实例。由于在 XML 中所有这些都代表了不同的概念，因此它们总是作为自己的类型被引用，而不是作为一个含糊的“结点”。
  
• 类驱动。因为 JDOM 对象就是像 Document 、 Element 和 Attribute 这些类的直接实例，因此创建一个新 JDOM 对象就如在 Java 语言中使用 new 操作符一样容易。它还意味着不需要进行工厂化接口配置 -- JDOM 的使用是直截了当的。

回页首

看，没有 Node ：建立和操作 JDOM 文档

JDOM 使用标准的 Java 编码模式。只要有可能，它使用 Java new 操作符而不用复杂的工厂化模式，使对象操作即便对于初学用户也很方便。例如，让我们看一下如何随便使用 JDOM 建立一个简单的 XML 文档。我们将要建立的结构如清单 1 所示。（从 参考资料上可下载关于本文的完整代码）

<?xml version="1.0" encoding="UTF-8"?>
            <car vin="123fhg5869705iop90">
            <!--Description of a car-->
            <make>Toyota</make>
            <model>Celica</model>
            <year>1997</year>
            <color>green</color>
            <license state="CA">1ABC234</license>
            </car>
            

注意：我们将建立 示例文档，在下面的清单 2 到清单 7 中有详细描述。

开始，让我们先创建一个根元素，并将其添加到文档中：

Element carElement = new Element("car");
            Document myDocument = new Document(carElement);
            

这一步创建一个新 org.jdom.Element ，并将其作为 org.jdom.Document myDocument 的根元素。（如果您使用 参考资料中提供的样本代码，请务必导入 org.jdom.* 。）因为一个 XML 文档必须一直有一个唯一的根元素，所以 Document 将 Element 放在它的构造器中。

下一步，添加 vin 属性：

carElement.addAttribute(new Attribute("vin", "123fhg5869705iop90"));
            

添加元素也是很简单的。这里我们添加 make 元素：

Element make = new Element("make");
            make.addContent("Toyota");
            carElement.addContent(make);
            

由于 Element 的 addContent 方法返回 Element ，我们也可以这样写：

carElement.addContent(new Element("make").addContent("Toyota"));
            

这两个语句完成了相同的工作。有些人认为第一个示例可读性更好，但是如果您一次建立许多元素，您会觉得第二个示例可读性更好。要完成构建文档：

carElement.addContent(new Element("model").addContent("Celica"));
            carElement.addContent(new Element("year").addContent("1997"));
            carElement.addContent(new Element("color").addContent("green"));
            carElement.addContent(new Element("license")
            .addContent("1ABC234").addAttribute("state", "CA"));
            

您会注意到对于 license 元素，我们不但添加了元素的内容，还为其添加了一个属性，表明许可已被发出了这个状态。这是因为 Element 的 addContent 方法总是返回 Element 本身，而不是一个无效的声明。

用同样的方法添加注释部分或其它标准 XML 类型：

carElement.addContent(new Comment("Description of a car"));
            

操作文档也是用类似方式。例如，要引用 year 元素，我们使用 Element 的 getChild 方法：

Element yearElement = carElement.getChild("year");
            

该语句实际上将返回第一个元素名为 year 的子 Element 。 如果没有 year 元素，则调用返回一个空值。注意，我们不必回溯来自任何类似于 DOM Node 接口的返回值 -- Element 的子元素就是 Element 。用类似的方式，我们可把 year 元素从文档中除去：

boolean removed = carElement.removeChild("year");
            

这次调用将只除去 year 元素；文档的其余部分保持不变。

到目前为止，我们已经涵盖了文档的生成和操作。要将完成的文档输出至控制台，可使用 JDOM 的 XMLOutputter 类：

try {
            XMLOutputter outputter = new XMLOutputter("  ", true);
            outputter.output(myDocument, System.out);
            } catch (java.io.IOException e) {
            e.printStackTrace();
            }
            

XMLOutputter 有几个格式选项。这里我们已指定希望子元素从父元素缩进两个空格，并且希望元素间有空行。 XMLOutputter 可输出到 Writer 或 OutputStream 。为输出到文件，我们可以简单地将输出行简化为：

FileWriter writer = new FileWriter("/some/directory/myFile.xml");
            outputter.output(myDocument, writer);
            writer.close();
            

回页首

与其它方法良好协作：和现有的 XML 工具进行互操作

JDOM 的一个有趣特征是和其它 API 有互操作性。使用 JDOM，不仅能把文档输出到 Stream 或 Reader ，还可将文档作为 SAX Event Stream 或作为 DOM Document 。这种灵活性允许 JDOM 能在多种环境下使用或被添加到已经在使用另一种方法处理 XML 的系统中去。正如我们在后面一个示例中所看到的，它还允许 JDOM 使用其它的还不能识别 JDOM 的数据结构的 XML 工具。

JDOM 的另一个用处是它能够读取并操作现有的 XML 数据。使用 org.jdom.input 中的一个类可以阅读结构很规范的 XML 文件。在这个示例中我们使用 SAXBuilder ：

try {
            SAXBuilder builder = new SAXBuilder();
            Document anotherDocument =
            builder.build(new File("/some/directory/sample.xml"));
            } catch(JDOMException e) {
            e.printStackTrace();
            } catch(NullPointerException e) {
            e.printStackTrace();
            }
            

您可以用清单 2 到清单 7 中显示的方法来操作通过这个过程建立的文档。

JDOM 的另一个实用应用程序将其与 Apache 的 Xalan 产品结合在一起（请参阅 参考资料）。使用上面的汽车示例，我们将为在线汽车经销商建立一个 Web 页面，显示特定汽车的详细信息。首先，假设我们上面建立的文档显示我们准备呈现给用户的汽车的信息。下一步，我们将把这个 JDOM Document 与一个 XSL 样式表结合起来并把 HTML 格式的结果输出到 servlet 的 OutputStream 上以便在用户的浏览器中显示。

在本例中，我们准备使用的 XSL 样式表被称为 car.xsl ：

<?xml version="1.0" encoding="UTF-8"?>
            <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
            <xsl:template match="/car">
            <html>
            <head>
            <title><xsl:value-of select="make"/> <xsl:value-of select="model"/>
            </head>
            <body>
            <h1><xsl:value-of select="make"/></h1><br />
            <h2><xsl:value-of select="model"/></h2><br />
            <table border="0">
            <tr><td>VIN:</td><td><xsl:value-of select="@vin"/></td></tr>
            <tr><td>Year:</td><td><xsl:value-of select="year"/></td></tr>
            <tr><td>Color:</td><td><xsl:value-of select="color"/></td></tr>
            </table>
            </body>
            </html>
            </xsl:template>
            </xsl:stylesheet>
            

现在我们将把 org.jdom.Document 转换为 DOM Document ，并将其与显示我们的 XSL 和 OutputStream 的文件一起提供给 Xalan， OutputStream 是我们从我们假定的使用 servlet（如清单 14 所示）的应用服务器上获取的。

TransformerFactory tFactory = TransformerFactory.newInstance();
            // Make the input sources for the XML and XSLT documents
            org.jdom.output.DOMOutputter outputter = new org.jdom.output.DOMOutputter();
            org.w3c.dom.Document domDocument = outputter.output(myDocument);
            javax.xml.transform.Source xmlSource =
            new javax.xml.transform.dom.DOMSource(domDocument);
            StreamSource xsltSource =
            new StreamSource(new FileInputStream("/some/directory/car.xsl"));
            // Make the output result for the finished document using
            // the HTTPResponse OutputStream
            StreamResult xmlResult = new StreamResult(response.getOutputStream());
            // Get a XSLT transformer
            Transformer transformer = tFactory.newTransformer(xsltSource);
            // Do the transform
            transformer.transform(xmlSource, xmlResult);
            

在这个示例中，输出是通过 Java servlet 的 HTTPResponse OutputStream 流出。然而，输出流可以象早期的使用 XMLOutputter 的实例一样简单的通过文件流输出。我们使用 DOMOutputter 为 Xalan 生成 XML 源代码。但是我们可以生成相同的输出，方法是使用 XMLOutputter 将我们的 XML 文档作为 String 输出并使其进入 StreamSource 。说到灵活性：JDOM 可将它的结构作为 String 、SAX Event Stream 或 DOM Document 输出。这允许 JDOM 与能把任何这些模型作为输入的工具一起工作。（关于附加功能，请访问 JDOM Web 站点的 contrib 包，在那里您将发现一个基于 JDOM 工具的宝库，可提供基于 JDBC ResultSet 的构建器、XPATH 实现方法和其它更多工具。）

在短短几行代码中，JDOM 启用了许多功能，我们已经在 XML 中分析过并有计划地创建了 XML 文档，操作了那些文档，并使用它们产生 XML 驱动的 Web 页面。

一、JDOM 简介

JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。

JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念以及映射），把SAX和DOM的功能有效地结合起来。

在使用设计上尽可能地隐藏原来使用XML过程中的复杂性。利用JDOM处理XML文档将是一件轻松、简单的事。

JDOM 在2000年的春天被Brett McLaughlin和Jason Hunter开发出来，以弥补DOM及SAX在实际应用当中的不足之处。

这些不足之处主要在于SAX没有文档修改、随机访问以及输出的功能，而对于DOM来说，JAVA程序员在使用时来用起来总觉得不太方便。

DOM的缺点主要是来自于由于Dom是一个接口定义语言（IDL）,它的任务是在不同语言实现中的一个最低的通用标准，并不是为JAVA特别设计的。JDOM的最新版本为JDOM Beta 9。最近JDOM被收录到JSR-102内，这标志着JDOM成为了JAVA平台组成的一部分。

二、JDOM 包概览

JDOM是由以下几个包组成的
org.jdom                包含了所有的xml文档要素的java类

org.jdom.adapters         包含了与dom适配的java类

org.jdom.filter            包含了xml文档的过滤器类

org.jdom.input            包含了读取xml文档的类

org.jdom.output           包含了写入xml文档的类

org.jdom.transform        包含了将jdom xml文档接口转换为其他xml文档接口

org.jdom.xpath            包含了对xml文档xpath操作的类三、JDOM 类说明

1、org.JDOM这个包里的类是你J解析xml文件后所要用到的所有数据类型。

Attribute

CDATA

Coment

DocType

Document

Element

EntityRef

Namespace

ProscessingInstruction

Text

2、org.JDOM.transform在涉及xslt格式转换时应使用下面的2个类

JDOMSource

JDOMResult

org.JDOM.input

3、输入类，一般用于文档的创建工作

SAXBuilder

DOMBuilder

ResultSetBuilder

org.JDOM.output

4、输出类，用于文档转换输出

XMLOutputter

SAXOutputter

DomOutputter

JTreeOutputter

使用前注意事项：

1.JDOM对于JAXP 以及 TRax 的支持

JDOM 支持JAXP1.1：你可以在程序中使用任何的parser工具类,默认情况下是JAXP的parser。

制定特别的parser可用如下形式

SAXBuilder parser

= new SAXBuilder("org.apache.crimson.parser.XMLReaderImpl");

Document doc = parser.build("http://www.cafeconleche.org/");

// work with the document...

JDOM也支持TRaX：XSLT可通过JDOMSource以及JDOMResult类来转换（参见以后章节）

2.注意在JDOM里文档（Document）类由org.JDOM.Document 来表示。这要与org.w3c.dom中的Document区别开，这2种格式如何转换在后面会说明。

以下如无特指均指JDOM里的Document。

四、JDOM主要使用方法

1.Ducument类

(1)Document的操作方法：

Element root = new Element("GREETING");

Document doc = new Document(root);

root.setText("Hello JDOM!");

或者简单的使用Document doc = new Document(new Element("GREETING").setText("Hello JDOM!t"));

这点和DOM不同。Dom则需要更为复杂的代码，如下：

DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();

DocumentBuilder builder =factory.newDocumentBuilder();

Document doc = builder.newDocument();

Element root =doc.createElement("root");

Text text = doc.createText("This is the root");

root.appendChild(text);

doc.appendChild(root);

注意事项：JDOM不允许同一个节点同时被2个或多个文档相关联，要在第2个文档中使用原来老文档中的节点的话。首先需要使用detach()把这个节点分开来。

(2)从文件、流、系统ID、URL得到Document对象：

DOMBuilder builder = new DOMBuilder();

Document doc = builder.build(new File("jdom_test.xml"));

SAXBuilder builder = new SAXBuilder();

Document doc = builder.build(url);

在新版本中DOMBuilder 已经Deprecated掉 DOMBuilder.builder(url)，用SAX效率会比较快。

这里举一个小例子，为了简单起见，使用String对象直接作为xml数据源：

public jdomTest() {

    String textXml = null;

    textXml = "<note>";

    textXml = textXml +

        "<to>aaa</to><from>bbb</from><heading>ccc</heading><body>ddd</body>";

    textXml = textXml + "</note>";

    SAXBuilder builder = new SAXBuilder();

    Document doc = null;

    Reader in= new StringReader(textXml);

    try {

      doc = builder.build(in);

      Element root = doc.getRootElement();

      List ls = root.getChildren();//注意此处取出的是root节点下面的一层的Element集合

      for (Iterator iter = ls.iterator(); iter.hasNext(); ) {

        Element el = (Element) iter.next();

        if(el.getName().equals("to")){

         System.out.println(el.getText());

        }

      }

    }

    catch (IOException ex) {

      ex.printStackTrace();

    }

    catch (JDOMException ex) {

      ex.printStackTrace();

    }

}

(3)DOM的document和JDOM的Document之间的相互转换使用方法，简单！

DOMBuilder builder = new DOMBuilder();

org.jdom.Document jdomDocument = builder.build(domDocument);

DOMOutputter converter = new DOMOutputter();// work with the JDOM document…

org.w3c.dom.Document domDocument = converter.output(jdomDocument);

// work with the DOM document…

2.XML文档输出

XMLOutPutter类：

JDOM的输出非常灵活,支持很多种io格式以及风格的输出

Document doc = new Document(...);

XMLOutputter outp = new XMLOutputter();

outp.output(doc, fileOutputStream); // Raw output

outp.setTextTrim(true); // Compressed output

outp.output(doc, socket.getOutputStream());

outp.setIndent(" ");// Pretty output

outp.setNewlines(true);

outp.output(doc, System.out);

详细请参阅最新的JDOM API手册

3.Element 类：

(1)浏览Element树

Element root = doc.getRootElement();//获得根元素element

List allChildren = root.getChildren();// 获得所有子元素的一个list

List namedChildren = root.getChildren("name");// 获得指定名称子元素的list

Element child = root.getChild("name");//获得指定名称的第一个子元素

JDOM给了我们很多很灵活的使用方法来管理子元素（这里的List是java.util.List）

List allChildren = root.getChildren();

allChildren.remove(3); // 删除第四个子元素

allChildren.removeAll(root.getChildren("jack"));// 删除叫“jack”的子元素

root.removeChildren("jack"); // 便捷写法

allChildren.add(new Element("jane"));// 加入

root.addContent(new Element("jane")); // 便捷写法

allChildren.add(0, new Element("first"));

(2)移动Elements:

在JDOM里很简单

Element movable = new Element("movable");

parent1.addContent(movable); // place

parent1.removeContent(movable); // remove

parent2.addContent(movable); // add

在Dom里

Element movable = doc1.createElement("movable");

parent1.appendChild(movable); // place

parent1.removeChild(movable); // remove

parent2.appendChild(movable); // 出错!

补充：纠错性

JDOM的Element构造函数（以及它的其他函数）会检查element是否合法。

而它的add/remove方法会检查树结构，检查内容如下：

1.在任何树中是否有回环节点

2.是否只有一个根节点

3.是否有一致的命名空间（Namespaces）

(3)Element的text内容读取

<description>

A cool demo

</description>

// The text is directly available

// Returns "\n A cool demo\n"

String desc = element.getText();

// There's a convenient shortcut

// Returns "A cool demo"

String desc = element.getTextTrim();

(4)Elment内容修改

element.setText("A new description");

3.可正确解释特殊字符

element.setText("<xml> content");

4.CDATA的数据写入、读出

element.addContent(new CDATA("<xml> content"));

String noDifference = element.getText();

混合内容

element可能包含很多种内容，比如说

<table>

<!-- Some comment -->

Some text

<tr>Some child element</tr>

</table>

取table的子元素tr

String text = table.getTextTrim();

Element tr = table.getChild("tr");

也可使用另外一个比较简单的方法

List mixedCo = table.getContent();

Iterator itr = mixedCo.iterator();

while (itr.hasNext()) {

Object o = i.next();

if (o instanceof Comment) {...}

// 这里可以写成Comment, Element, Text, CDATA,ProcessingInstruction, 或者是EntityRef的类型

}

// 现在移除Comment,注意这里游标应为1。这是由于回车键也被解析成Text类的缘故,所以Comment项应为1。

mixedCo.remove(1);

4.Attribute类

<table width="100%" border="0"> </table>

String width = table.getAttributeValue("width");//获得attribute

int border = table.getAttribute("width").getIntValue();

table.setAttribute("vspace", "0");//设置attribute

table.removeAttribute("vspace");// 删除一个或全部attribute

table.getAttributes().clear();

5.处理指令(Processing Instructions)操作

一个Pls的例子

<?br?>

<?cocoon-process type="xslt"?>

          |        |

          |        |

        目标     数据

处理目标名称(Target)

String target = pi.getTarget();

获得所有数据（data），在目标（target）以后的所有数据都会被返回。

String data = pi.getData();

String type = pi.getValue("type");获得指定属性的数据

List ls = pi.getNames();获得所有属性的名称

6.命名空间操作

<xhtml:html

xmlns:xhtml="http://www.w3.org/1999/xhtml">

<xhtml:title>Home Page</xhtml:title>

</xhtml:html>

Namespace xhtml = Namespace.getNamespace("xhtml", "http://www.w3.org/1999/xhtml");

List kids = html.getChildren("title", xhtml);

Element kid = html.getChild("title", xhtml);

kid.addContent(new Element("table", xhtml));

7.XSLT格式转换

使用以下函数可对XSLT转换

最后如果你需要使用w3c的Document则需要转换一下。

public static Document transform(String stylesheet，Document in)

                                        throws JDOMException {

     try {

       Transformer transformer = TransformerFactory.newInstance()

                             .newTransformer(new StreamSource(stylesheet));

       JDOMResult out = new JDOMResult();

       transformer.transform(new JDOMSource(in), out);

       return out.getDeocument();

     }

     catch (TransformerException e) {

       throw new JDOMException("XSLT Trandformation failed", e);

     }

   }

五、用例:

1、生成xml文档：

public class WriteXML{

    public void BuildXML() throws Exception {

        Element root,student,number,name,age;        

        root = new Element("student-info"); //生成根元素：student-info

        student = new Element("student"); //生成元素：student(number,name,age)                            

        number = new Element("number");

        name = new Element("name");

        age = new Element("age");

        Document doc = new Document(root); //将根元素植入文档doc中

        number.setText("001");

        name.setText("lnman");

        age.setText("24");

        student.addContent(number);

        student.addContent(name);

        student.addContent(age);

        root.addContent(student);

        Format format = Format.getCompactFormat();

        format.setEncoding("gb2312"); //设置xml文件的字符为gb2312

        format.setIndent("    "); //设置xml文件的缩进为4个空格

        XMLOutputter XMLOut = new XMLOutputter(format);//元素后换行一层元素缩四格

        XMLOut.output(doc, new FileOutputStream("studentinfo.xml"));

}

    public static void main(String[] args) throws Exception {

        WriteXML w = new WriteXML();

        System.out.println("Now we build an XML document .....");

        w.BuildXML();

        System.out.println("finished!");

}

}

生成的xml文档为：

<?xml version="1.0" encoding="gb2312"?>

<student-info>

    <student>

        <number>001</number>

        <name>lnman</name>

        <age>24</age>

    </student>

</student-info>

创建XML文档2：

public class CreateXML {

public void Create() {

   try {

    Document doc = new Document();  

    ProcessingInstruction pi=new ProcessingInstruction("xml-stylesheet","type="text/xsl" href="test.xsl"");

    doc.addContent(pi);   

    Namespace ns = Namespace.getNamespace("http://www.bromon.org" );

    Namespace ns2 = Namespace.getNamespace("other", "http://www.w3c.org" );

    Element root = new Element("根元素", ns);

    root.addNamespaceDeclaration(ns2);

    doc.setRootElement(root);

    Element el1 = new Element("元素一");

    el1.setAttribute("属性", "属性一");   

    Text text1=new Text("元素值");

             Element em = new Element("元素二").addContent("第二个元素");

    el1.addContent(text1);

             el1.addContent(em);            

             Element el2 = new Element("元素三").addContent("第三个元素");

             root.addContent(el1);

             root.addContent(el2);            

             //缩进四个空格,自动换行,gb2312编码

             XMLOutputter outputter = new XMLOutputter(" ", true,"GB2312");

             outputter.output(doc, new FileWriter("test.xml"));

         }catch(Exception e) {

          System.out.println(e);

         }

     }    

     public static void main(String args[]) {

      new CreateXML().Create();

     }    

}

2、读取xml文档的例子：

import org.jdom.output.*;

import org.jdom.input.*;

import org.jdom.*;

import java.io.*;

import java.util.*;

public class ReadXML{

    public static void main(String[] args) throws Exception {

        SAXBuilder builder = new SAXBuilder();

        Document read_doc = builder.build("studentinfo.xml");

        Element stu = read_doc.getRootElement();

        List list = stu.getChildren("student");

        for(int i = 0;i < list.size();i++) {

            Element e = (Element)list.get(i);

            String str_number = e.getChildText("number");

            String str_name = e.getChildText("name");

            String str_age = e.getChildText("age");

            System.out.println("---------STUDENT--------------");

            System.out.println("NUMBER:" + str_number);

            System.out.println("NAME:" + str_name);

            System.out.println("AGE:" + str_age);

            System.out.println("------------------------------");

            System.out.println();

        }

       }

}

3、DTD验证的：

public class XMLWithDTD {

public void validate() {

   try {

    SAXBuilder builder = new SAXBuilder(true);

    builder.setFeature("http://xml.org/sax/features/validation";,true);

    Document doc = builder.build(new FileReader("author.xml"));   

    System.out.println("搞掂");

    XMLOutputter outputter = new XMLOutputter();

    outputter.output(doc, System.out);

   }catch(Exception e) {

    System.out.println(e);

   }  

}

public static void main(String args[]) {

   new XMLWithDTD().validate();

}

}

　　需要说明的是，这个程序没有指明使用哪个DTD文件。DTD文件的位置是在XML中指定的，而且DTD不支持命名空间，一个XML只能引用一个DTD，所以程序直接读取XML中指定的DTD，程序本身不用指定。不过这样一来，好象就只能使用外部式的DTD引用方式了？高人指点。

4、XML Schema验证的：

public class XMLWithSchema {

String xml="test.xml";

String schema="test-schema.xml";

public void validate() {

   try {

    SAXBuilder builder = new SAXBuilder(true);

    //指定约束方式为XML schema

    builder.setFeature("http://apache.org/xml/features/validation/schema";, true);

    //导入schema文件

builder.setProperty("http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation";,schema);

    Document doc = builder.build(new FileReader(xml));   

    System.out.println("搞掂");

    XMLOutputter outputter = new XMLOutputter();

    outputter.output(doc, System.out);

   }catch(Exception e) {

    System.out.println("验证失败:"+e);

   }

}

}

上面的程序就指出了要引入的XML Schema文件的位置。

系统默认输出是UTF-8，这有可能导致出现乱码。

5、Xpath例子：

JDOM的关于XPATH的api在org.jdom.xpath这个包里。这个包下，有一个抽象类XPath.java和实现类JaxenXPath.java， 使用时先用XPath类的静态方法newInstance(String xpath)得到XPath对象，然后调用它的selectNodes(Object context)方法或selectSingleNode(Object context)方法，前者根据xpath语句返回一组节点(List对象)；后者根据一个xpath语句返回符合条件的第一个节点(Object类型)。请看jdom-1.0自带的范例程序：

     它分析在web.xml文件中的注册的servlet的个数及参数个数，并输出角色名。

web.xml文件：

<?xml version="1.0" encoding="ISO-8859-1"?>

<!--

<!DOCTYPE web-app

    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"

    "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd">

-->

<web-app>

    <servlet>

        <servlet-name>snoop</servlet-name>

        <servlet-class>SnoopServlet</servlet-class>

    </servlet>

    <servlet>

        <servlet-name>file </servlet-name>

        <servlet-class>ViewFile</servlet-class>

        <init-param>

            <param-name>initial</param-name>

            <param-value>1000</param-value>

            <description>The initial value for the counter <!-- optional --></description>

        </init-param>

    </servlet>

    <servlet-mapping>

        <servlet-name>mv</servlet-name>

        <url-pattern>*.wm</url-pattern>

    </servlet-mapping>

    <distributed/>

    <security-role>

      <role-name>manager</role-name>

      <role-name>director</role-name>

      <role-name>president</role-name>

    </security-role>

</web-app>

处理程序：

import java.io.*;

import java.util.*;

public class XPathReader {     

    public static void main(String[] args) throws IOException, JDOMException {

        if (args.length != 1) {

            System.err.println("Usage: java XPathReader web.xml");

            return;

        }

        String filename = args[0];//从命令行输入web.xml

        PrintStream out = System.out;

        SAXBuilder builder = new SAXBuilder();

        Document doc = builder.build(new File(filename));//得到Document对象

        // Print servlet information

        XPath servletPath = XPath.newInstance("//servlet");//,选择任意路径下servlet元素

        List servlets = servletPath.selectNodes(doc);//返回所有的servlet元素。

        out.println("This WAR has "+ servlets.size() +" registered servlets:");

        Iterator i = servlets.iterator();

        while (i.hasNext()) {//输出servlet信息

            Element servlet = (Element) i.next();

            out.print("\t" + servlet.getChild("servlet-name")

                                    .getTextTrim() +

                      " for " + servlet.getChild("servlet-class")

                                       .getTextTrim());

            List initParams = servlet.getChildren("init-param");

            out.println(" (it has " + initParams.size() + " init params)");

        }             

        // Print security role information

        XPath rolePath = XPath.newInstance("//security-role/role-name/text()");

        List roleNames = rolePath.selectNodes(doc);//得到所有的角色名

        if (roleNames.size() == 0) {

            out.println("This WAR contains no roles");

        } else {

            out.println("This WAR contains " + roleNames.size() + " roles:");

            i = roleNames.iterator();

            while (i.hasNext()) {//输出角色名

                out.println("\t" + ((Text)i.next()).getTextTrim());

            }

        }

    }    

}

输出结果:

C:\java>java   XPathReader web.xml

This WAR has 2 registered servlets:

        snoop for SnoopServlet (it has 0 init params)

        file for ViewFile (it has 1 init params)

This WAR contains 3 roles:

        manager

        director

        president

6、数据输入要用到XML文档要通过org.jdom.input包，反过来需要org.jdom.output。如前面所说，关是看API文档就能够使用。

我们的例子读入XML文件exampleA.xml，加入一条处理指令，修改第一本书的价格和作者，并添加一条属性，然后写入文件exampleB.xml：

//exampleA.xml

<?xml version="1.0" encoding="GBK"?>

<bookList>

<book>

<name>Java编程入门</name>

<author>张三</author>

<publishDate>2002-6-6</publishDate>

<price>35.0</price>

</book>

<book>

<name>XML在Java中的应用</name>

<author>李四</author>

<publishDate>2002-9-16</publishDate>

<price>92.0</price>

</book>

</bookList>

//testJDOM.java

import org.jdom.*;

import org.jdom.output.*;

import org.jdom.input.*;

import java.io.*;

public class TestJDOM{

public static void main(String args[])throws Exception{

SAXBuilder sb = new SAXBuilder();

//从文件构造一个Document，因为XML文件中已经指定了编码，所以这里不必了

Document doc = sb.build(new FileInputStream("exampleA.xml"));

ProcessingInstruction pi = new ProcessingInstruction//加入一条处理指令

("xml-stylesheet","href=\"bookList.html.xsl\" type=\"text/xsl\"");

doc.addContent(pi);

Element root = doc.getRootElement(); //得到根元素

java.util.List books = root.getChildren(); //得到根元素所有子元素的集合

Element book = (Element)books.get(0); //得到第一个book元素

//为第一本书添加一条属性

Attribute a = new Attribute("hot","true");

book.setAttribute(a);

Element author = book.getChild("author"); //得到指定的字元素

author.setText("王五"); //将作者改为王五

//或 Text t = new Text("王五");book.addContent(t);

Element price = book.getChild("price"); //得到指定的字元素

//修改价格，比较郁闷的是我们必须自己转换数据类型，而这正是JAXB的优势

author.setText(Float.toString(50.0f));

String indent = " ";

boolean newLines = true;

XMLOutputter outp = new XMLOutputter(indent,newLines,"GBK");

outp.output(doc, new FileOutputStream("exampleB.xml"));

}

};

执行结果exampleB.xml：

<?xml version="1.0" encoding="GBK"?>

<bookList>

<book hot=”true”>

<name>Java编程入门</name>

<author>50.0</author>

<publishDate>2002-6-6</publishDate>

<price>35.0</price>

</book>

<book>

<name>XML在Java中的应用</name>

<author>李四</author>

<publishDate>2002-9-16</publishDate>

<price>92.0</price>

</book>

</bookList>

<?xml-stylesheet href="bookList.html.xsl" type="text/xsl"?>

在默认情况下，JDOM的Element类的getText()这类的方法不会过滤空白字符，如果你需要过滤，用setTextTrim() 。

     java.util.Map.Entry。这时var=entry的话，用表达式${entry.key}取得键名。

　 用表达式${entry.value}得到每个entry的值。这是因为java.util.Map.Entry对象有getKey和getValue方

　法，表达式语言遵守JavaBean的命名约定。　example:

     <c:forEach items="${map}" var="entry">

        <c:out value="${entry.key}" />

        <c:out value="${entry.value}" />

     </c:forEach>
2、根据key变量求值
      如果事先知道key那么很容易根据${map.key值}就可以得到值对象，但是如果key是一个变量呢？

     有一个问题,如果给定一个key的变量如何使用EL得到对象呢,这里需要使用EL表达式中的[]来解决,

     解决方法如示例:

     <c:out value="${map[key]}" />

      <!-- 这里的map就是 java.util.Map对像，key是这个map里的一个key -->
 

{

final int ACCOUNTANT = 1;

final int PAYROLL_CLERK = 2;

final int MANAGER = 3;

int jobID = ACCOUNTANT;

}如果你将一个字段声明为volatile，则多线程将能访问此字段，而特定的编译器将防止最优化以使该字段能被适当的访问。如果你将一个字段定义为static，则所有对象都将共享此字段的一份拷贝。当你将一个新值赋给这个字段时，所有对象都将得到这个新值。如果没有指定为static，则这个字段将是一个实例字段，每个对象都使用他们自己的一份拷贝。
定义为transient的字段值在对象串行化过程中将不被保存。实例字段
“实例字段”就是没有使用static修改标识符定义的字段。实例字段和对象紧密相连——而不是和类。当在一个对象代码里修改时，仅仅这个相关的类实例——对象——可以得到这个改变。实例字段随对象的创建而创建，随对象的释放而释放。类字段
类字段是用static关键字定义的字段。类字段和类联系——而不是对象。当在一个类代码中修改时，这个类（以及所有创建的对象）都能感知这个变化。类字段随类的加载而创建，随类的卸载而释放常量
“常量”是一种只读变量；当JVM初始化这种变量后，变量的值就不能改变了。
使用final关键字来定义常量。正如有两种字段——实例和类字段，常量也有两种——实例常量和类常量。为了提高效率，应当创建类常量，或者说是final static字段。class Constants

{

final int FIRST = 1;

final static int SECOND = 2;

public static void main(String[] args)

{

int iteration = SECOND;

if (iteration == FIRST)//编译错误

System.out.println(“first iteration”);

else

if (iteration == SECOND)

System.out.println(“second iteration”);

}

}
上例中的Constants类定义了一对常量——FIRST和SECOND。FIRST是实例常量，因为JVM给每个Constants对象分配一份FIRST的拷贝。相反的，因为JVM在加载Constants类后只创建了一份SECOND拷贝，所以SECOND是类常量。
注意：当你尝试在main()中直接访问FIRST时会导致一个编译错误。常量FIRST直到一个对象创建时才存在，所以FIRST仅仅只能被这个对象所访问——而不是类。