• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

随着富 Internet 应用（ RIA ）技术的不断成熟，将类似于 Adobe Flex 这样的 RIA 应用与健壮的服务器端技术进行集成就变得越来越重要了。 Java 开发者最喜欢的服务器端框架之一 Spring 将在这个过程中扮演着重要的角色。

Spring 的控制反转（ Inversion of Control ， 即 IoC ）的主要思想就是让容器实例化组件（并且注入其依赖）。但是在默认情况下，由 Flex 客户端远程访问的组件是在服务器端由 Flex 目的文件实例化的。所以 Flex 与 Spring 集成的关键在于配置 Flex 目的文件以使其能够让 Spring 容器来管理实例化的 Spring beans 。 Flex 数据服务支持工厂的概念以便可以实例化这类客户化组件。工厂的作用仅仅在于向 Flex 目的文件提供准备好的组件实例，而不是让 Flex 目的文件自己去实例化这些组件。

Sébastien Arbogast 在不遗余力地发表一系列博文，以阐述如何构建全栈式 Flex 、 BlazeDS 和 Spring 集成解决方案。 Arbogast 的这个全栈式集成，从下到上包括如下内容： JBoss 作为应用服务器、 MySQL 作为数据存储、 Hibernate 完成数据访问、 Spring 用来构建业务层、 BlazeDS 作为远程服务、 Flex 用来构建富客户端。该系统使用 Maven 及 flex-compiler-mojo插件 进行构建。 [1]

我翻译的中文文档下载地址：

      http://download.csdn.net/source/672504

 本文档就是 Arbogast 发布在 Adobe Developer Connection 上一系列文章的中文翻译版本。我使用了先直译后意译的方法，尽量做到语言流畅、通俗而易懂；修补了英文原文的 3 处疏漏 ，添加了 2 张运行效果图，希望能帮助你理解。当然，翻译不恰之处，敬请指正。

 以下是英文原文链接：

第一部分： http://www.adobe.com/devnet/flex/articles/fullstack_pt1.html

第二部分： http://www.adobe.com/devnet/flex/articles/fullstack_pt2.html

第三部分： http://www.adobe.com/devnet/flex/articles/fullstack_pt3.html

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

package org.jrest4guice.persistence.ibatis;
public class Account {
  private int id;
  private String firstName;
  private String lastName;
  private String emailAddress;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmailAddress() {
    return emailAddress;
  }

  public void setEmailAddress(String emailAddress) {
    this.emailAddress = emailAddress;
  }

}

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import org.jrest4guice.persistence.ibatis.annotations.Delete;
import org.jrest4guice.persistence.ibatis.annotations.IbatisDao;
import org.jrest4guice.persistence.ibatis.annotations.Insert;
import org.jrest4guice.persistence.ibatis.annotations.Result;
import org.jrest4guice.persistence.ibatis.annotations.ResultMap;
import org.jrest4guice.persistence.ibatis.annotations.Select;
import org.jrest4guice.persistence.ibatis.annotations.Update;
import org.jrest4guice.transaction.annotations.Transactional;
import org.jrest4guice.transaction.annotations.TransactionalType;

import com.google.inject.Inject;
import com.ibatis.sqlmap.client.SqlMapClient;

@IbatisDao
@SuppressWarnings("unchecked")
@Transactional
@ResultMap(id = "accountResultMap", result = {
		@Result(property = "id", column = "id"),
		@Result(property = "firstName", column = "firstName"),
		@Result(property = "lastName", column = "lastName"),
		@Result(property = "emailAddress", column = "emailAddress") }, resultClass = Account.class)
@Cachemodel(id = "account-cache", flushInterval = "24", flushOnExecute = {
		"insertAccount", "updateAccount", "deleteAccount" }, type = "LRU", 
		property = { @Property(name = "size", value = "100") })
public class AccountService {
	@Inject
	private SqlMapClient sqlMapper;

	@Select(id = "selectAllAccounts", sql = "select * from ACCOUNT", 
			resltMap = "accountResultMap", cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	public List<Account> findAll() throws SQLException {
		return sqlMapper.queryForList("selectAllAccounts");
	}

	@Select(sql = "select id ,firstName,lastName,emailAddress from "
			+ "ACCOUNT where id = #id#")
	@Transactional(type = TransactionalType.READOLNY)
	public Account getAccountById(int id) throws SQLException {
		return (Account) sqlMapper.queryForObject("getAccountById", id);
	}

	@Insert(id = "insertAccount", sql = "insert into ACCOUNT (id,firstName,"
			+ "lastName,emailAddress) values (#id#, #firstName#, #lastName#, "
			+ "#emailAddress#)")
	public void createAccount(Account account) throws SQLException {
		sqlMapper.insert("insertAccount", account);
	}

	@Update(sql = "update ACCOUNT set firstName = #firstName#,lastName = "
			+ "#lastName#,emailAddress = #emailAddress# where id = #id#")
	public void updateAccount(Account account) throws SQLException {
		sqlMapper.update("updateAccount", account);
	}

	@Delete(id = "deleteAccount", sql = "delete from ACCOUNT where id = #id#")
	public void deleteAccount(int id) throws SQLException {
		sqlMapper.delete("deleteAccount", id);
	}

	@Select(id = "queryAccounts", 
		sql = "select * from ACCOUNT "
			+ "<dynamic prepend=\"where\">"
			+ " <isNotNull prepend=\"and\" property=\"firstName\">"
			+ "    firstName = #firstName#" 
			+ " </isNotNull>"
			+ " <isNotNull prepend=\"and\" property=\"lastName\">"
			+ "    lastName = #lastName#" 
			+ " </isNotNull>"
			+ " <isNotNull prepend=\"and\" property=\"emailAddress\">"
			+ "    emailAddress = #emailAddress#" 
			+ " </isNotNull>"
			+ "</dynamic> " 
			+ "order by lastName", resltMap = "accountResultMap", 
			cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	/**
	 * 动态SQL查询
	 */
	public List<Account> queryAccounts(Account account) throws SQLException {
		return sqlMapper.queryForList("queryAccounts",account);
	}
}

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import junit.framework.Assert;

import org.jrest4guice.guice.GuiceContext;
import org.jrest4guice.guice.PersistenceGuiceContext;
import org.junit.BeforeClass;
import org.junit.Test;

public class AccountServiceTest {
	private static AccountService service;

	@BeforeClass
	public static void setUp() throws Exception {
		// 初始化JRest4Guice
		PersistenceGuiceContext.getInstance().useIbatis(
				"org.jrest4guice.persistence.ibatis").init();
		// 获取服务
		service = GuiceContext.getInstance().getBean(AccountService.class);
	}

	@Test
	public void doTest() {
		List<Account> accounts;
		try {
			Account account = new Account();
			account.setFirstName("张");
			account.setLastName("学友");
			account.setEmailAddress("jackey@rest4g.org");
			// 添加
			service.createAccount(account);

			account = new Account();
			account.setFirstName("刘");
			account.setLastName("学友");
			account.setEmailAddress("test@rest4g.org");
			// 添加
			service.createAccount(account);
			
			//查询（按lastName）
			Account queryCondition = new Account();
			queryCondition.setLastName("学友");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(2, accounts.size());
			
			//查询（按firstName和lastName）
			queryCondition.setFirstName("张");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(1, accounts.size());

			// 修改
			account = accounts.get(0);
			account.setFirstName("何");
			service.updateAccount(account);
			account = service.getAccountById(account.getId());
			Assert.assertNotNull(account);
			Assert.assertEquals("何", account.getFirstName());

			//查询所有
			accounts = service.findAll();
			Assert.assertEquals(2, accounts.size());

			// 删除
			for (Account ac : accounts){
				service.deleteAccount(ac.getId());
			}
			
			//断言删除的结果
			accounts = service.findAll();
			Assert.assertEquals(0, accounts.size());
		} catch (SQLException e) {
			Assert.fail(e.getLocalizedMessage());
		}
	}
}

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

      在搭建系统的架构时我们采用了ssh+ajax等方式构建的。我一在和大家说我们要层次分明，思路清晰，可现在都比较糟糕。

       比如：JSP页面用来显示数据的，css用来美化页面，JS用来控制页面的。现在很多页面中什么都有了，臭味很多。

       在后台我们也分了action,service,dao层，原本action用来控制调度的，service用来处理相关的业务逻辑的，DAO中用来CRUD数据的。可现在出现了action包裹着一部分逻辑，service就非常简单了，就是用来调用DAO中的方法，而DAO中的方法即包裹了业务处理逻辑又包裹了CRUD数据处理。而且有的业务逻辑非常的复杂，涉及到的表操作很多，比如有

//结合spring支持hibernate
Session session = getSession();

//可以能会处理的一些东西
//1)通过hibernate方法select数据
//2)通过hibernate方法update数据
//3)通过hibernate方法delete数据
//4)通过hibernate方法insert数据

//通过session获取Connection，使用JDBC进行数据处理
Connection con = session.getConnection();
//因为有一些逻辑很负责一个select语句涉及的表太多，所以用JDBC来处理。

String sql = "select a ,b ,c ,d from A ,B,C,D where a = ? and b=?";
//反正类似的操作吧，就是关连来多。

 类似上面的方式，大多数同学在大多数的时候都是这么弄的。我觉得这样做就把业务逻辑和数据处理混淆了，方法太臃肿了，有着浓浓的臭味，不便于维护。XP中提倡面向接口编程、分层、短小的方法。它这么一个长长的方法占用一个连接的时间太长（也就是整个事务的时间延长了），那么当其他的用户对相关的表进行请求时，就会出于等待的状态，资源的竞争，如果长时间是这样死锁就出现了。：（

     我一般会把他们分布在不同的方法中。

//对应表的相关操作
public interface DAO{
     public List get##(String s);
     public void update##(String ...);
     public void delete##(String ...);
     public void insert##(String ...);
     public List find##(String...);

}


public class Service{
    public DAO dao = .......;//注入DAO对象。

    //结合DAO执行相应的业务处理操作
    public List update###(){
           dao.get(s);
           dao.update##(String ...);
           dao.delete##(String ...);
           dao.insert##(String ...);

           //处理更复杂的业务逻辑。
           logice();

           return dao.find##(String...);
   } 

    public void logice(){  
          //to do something  
  } 
   
}

 这样我的每一个DAO中的方法就会用到不同的SESSION（不同的CONNECTION），是这样的吗？但是我是通过SPRING对service层进行事务处理的呀，那是不是说明两种方式都会要占用同样的事务处理资源？

     看到那些贫血的SERVICE我就郁闷，现在我有检查代码是否存在问题我也迷茫，这事情做的太少了。很多时候我们只顾一直往前跑，没有时间回头看。其实，我们要经常的code view，使用TDD开发模式，用XP的小步发布，这样不要让代码的味道变的太坏，也对自己写的代码充满信心，和用户交流底气十足。开发出来的系统，用户满意，市场行情看涨。：）

请您提出宝贵的意见。

更新：2008-10-10 22：00

我把标题从“DAO实现方法中一个Connection捅到底好吗？头疼”改成“细粒度处理事务，尽快的结束事务”，这个是我最终的目的。现在我明白了整 个业务方法调用过程中都是使用同一个SESSION（Connection）。至于业务逻辑怎样来平衡分布，是不是可以把一部分放到ACTION，一部分放到service，Dao只负责和数据库处理。对只读的事务我对其只用readOnly。

比如：我上面的例子是不是可以变成如下的样子呢？

//对应表的相关操作
public interface DAO{
     public List get##(String s);
     public void update##(String ...);
     public void delete##(String ...);
     public void insert##(String ...);
     public List find##(String...);

}


public class Service{
    public DAO dao = .......;//注入DAO对象。

    //结合DAO执行相应的业务处理操作
    //该方法上加事务，传播途径为required
    public void update###(){
          
           dao.update##(String ...);
           dao.delete##(String ...);
           dao.insert##(String ...);

           //处理更复杂的业务逻辑。
           logice();
   } 
 
   
   //该方法上加事务，传播途径为required,readOnly
   public  String get###(String s){
          return dao.get(s);
   }

  
   //该方法上加事务，传播途径为required,readOnly
   public List find###(String...){
          return dao.find##(String...);
   }

    public void logice(){  
          //to do something  
  } 
   
}

/**
*那么action中是不是可以变成如下的样子呢？
*
*/
public class Action{
     //注入服务类
     public Service service = null;
     public ActoinForward update###(ActionForm...............){
           //下面这样调用是不是会能更好的呢？
            service. get###(s);
            service. update###();
            service. find###(String...);
    }
}

   我们希望能够更快的结束事务，避免不必要的阻塞，保证系统有更好的性能。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

 编译Schema:
xjc jxl.xsd -p jxl.jaxb
生成N多文件：

生成的Java文件全部放在jxl.jaxb包下。

然后对Excel类编辑：

@XmlRootElement(name="excel")//添加
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "excel", propOrder = {
    "format",
    "sheet"
})
public class Excel {

    ...

}

JAXBExcel类：

构造函数：

public JAXBExcel(Source xml, Source xsl) {
	try {
		Transformer trans = TransformerFactory.newInstance()
				.newTransformer(xsl);
		JAXBContext context = JAXBContext.newInstance("jxl.jaxb");
		JAXBResult result = new JAXBResult(context);
		trans.transform(xml, result);
		table = (Excel) result.getResult();
		Marshaller marshaller = context.createMarshaller();
		marshaller.setProperty("jaxb.formatted.output", true);
		marshaller.setProperty("jaxb.encoding", "UTF-8");
		marshaller.marshal(table, System.out);
	} catch (Exception e) {
		e.printStackTrace();
		throw new RuntimeException(e.getMessage());
	}
}

处理XML文件：

public void process(OutputStream os) throws IOException, WriteException,
		ParseException {
	if (table == null) {
		throw new RuntimeException("The table is not init yet");
	}
	processFormat(table.getFormat());
	WritableWorkbook excel = Workbook.createWorkbook(os);
	Iterator<ExcelSheet> excelSheets = table.getSheet().iterator();
	for (int i = 0; excelSheets.hasNext(); i++) {
		ExcelSheet sheetData = excelSheets.next();
		WritableSheet sheet = excel.createSheet(sheetData.getName(), i);
		// sheet.getSettings().setProtected(true);
		// sheet.getSettings().setPassword("zhaobq");
		// 锁定单元格，设置保护密码
		int row = 0;
		if (sheetData.getHead().getRow().size() > 0) {
			this.setView(sheet, sheetData.getHead().getRow().get(
					sheetData.getHead().getRow().size() - 1));
		}

		row = processTitle(sheetData.getTitle(), sheet, row);
		row = processHead(sheetData.getHead(), sheet, row);
		row = processBody(sheetData.getBody(), sheet, row);
		row = processFoot(sheetData.getFoot(), sheet, row);
	}// TABLE
	excel.write();
	excel.close();
}

JAXBExcel类中公共的方法就这两个：

首先用XML数据文件和XSL模板文件构造JAXBExcel对象，

然后用JAXBExcel.process()得到文件的输出流

全部代码：

package jxl;

import static jxl.write.WritableFont.ARIAL;
import static jxl.write.WritableFont.BOLD;
import static jxl.write.WritableFont.DEFAULT_POINT_SIZE;
import static jxl.write.WritableFont.NO_BOLD;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*；
import javax.xml.bind.*;
import javax.xml.bind.util.JAXBResult;
import javax.xml.transform.*;

import jxl.format.*;
import jxl.jaxb.*;
import jxl.write.*;

/**
 * 
 * @author Allen 赵本钱
 *
 */
public class JAXBExcel {

	private Excel table = null;

	/**
	 * 默认CELLFORMAT
	 */
	public static Map<String, WritableCellFormat> CELL_FORMAT = new HashMap<String, WritableCellFormat>();

	private Map<String, WritableCellFormat> cellFormat = null;

	private String numberFormat = "####.##";

	private String dateFormat = "yyyy-MM-dd";

	private static List<String> COLUMN_TYPE = new ArrayList<String>();

	static {
		WritableFont foot = new WritableFont(ARIAL, 10);
		WritableFont body = foot;
		WritableFont head = new WritableFont(ARIAL, 10);
		WritableFont title = new WritableFont(ARIAL, 15);
		try {
			head.setBoldStyle(BOLD);

			title.setBoldStyle(BOLD);
		} catch (WriteException e) {
			e.printStackTrace();
		}
		WritableCellFormat cfoot = new WritableCellFormat();
		WritableCellFormat cbody = cfoot;
		WritableCellFormat chead = new WritableCellFormat();
		WritableCellFormat ctitle = new WritableCellFormat();
		try {
			cfoot.setAlignment(Alignment.GENERAL);
			cfoot.setWrap(false);

			chead.setAlignment(Alignment.CENTRE);
			chead.setWrap(false);
			chead.setBackground(Colour.GRAY_25);

			ctitle.setAlignment(Alignment.CENTRE);
			ctitle.setWrap(false);
		} catch (WriteException e) {
			e.printStackTrace();
		}
		cfoot.setFont(foot);
		cbody.setFont(body);
		chead.setFont(head);
		ctitle.setFont(title);
		CELL_FORMAT.put("foot", cfoot);
		CELL_FORMAT.put("body", cbody);
		CELL_FORMAT.put("head", chead);
		CELL_FORMAT.put("title", ctitle);
	}

	public JAXBExcel(Source xml, Source xsl) {
		try {
			Transformer trans = TransformerFactory.newInstance().newTransformer(xsl);
			JAXBContext context = JAXBContext.newInstance("jxl.jaxb");
			JAXBResult result = new JAXBResult(context);
			trans.transform(xml, result);
			table = (Excel) result.getResult();
			Marshaller marshaller = context.createMarshaller();
			marshaller.setProperty("jaxb.formatted.output", true);
			marshaller.setProperty("jaxb.encoding", "UTF-8");
			marshaller.marshal(table, System.out);
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e.getMessage());
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see jxl.Excel#process(java.io.OutputStream)
	 */
	public void process(OutputStream os) throws IOException, WriteException, ParseException {
		if (table == null) {
			throw new RuntimeException("The table is not init yet");
		}
		processFormat(table.getFormat());
		WritableWorkbook excel = Workbook.createWorkbook(os);
		Iterator<ExcelSheet> excelSheets = table.getSheet().iterator();
		for (int i = 0; excelSheets.hasNext(); i++) {
			ExcelSheet sheetData = excelSheets.next();
			WritableSheet sheet = excel.createSheet(sheetData.getName(), i);
			// sheet.getSettings().setProtected(true);
			// sheet.getSettings().setPassword("zhaobq");
			// 锁定单元格，设置保护密码
			int row = 0;
			if (sheetData.getHead().getRow().size() > 0) {
				this.setView(sheet, sheetData.getHead().getRow().get(sheetData.getHead().getRow().size() - 1));
			}

			row = processTitle(sheetData.getTitle(), sheet, row);
			row = processHead(sheetData.getHead(), sheet, row);
			row = processBody(sheetData.getBody(), sheet, row);
			row = processFoot(sheetData.getFoot(), sheet, row);
		}// TABLE
		excel.write();
		excel.close();
	}

	private void setView(WritableSheet sheet, ExcelRow view) {
		Iterator<ExcelHCell> hcell = view.getHcell().iterator();
		for (int i = 0; hcell.hasNext(); i++) {
			ExcelHCell c = hcell.next();
			if (null != c.getWidth()) {
				sheet.setColumnView(i, c.getWidth());
			}
			if (null != c.getType()) {
				COLUMN_TYPE.add(c.getType());
			} else {
				COLUMN_TYPE.add("string");
			}
		}
	}

	/**
	 * 处理Format节点
	 * 
	 * @param format
	 * @throws WriteException
	 */
	private void processFormat(Format format) throws WriteException {
		if (format == null) {
			return;
		}
		Iterator<CellFormat> cf = format.getCellFormat().iterator();

		cellFormat = new HashMap<String, WritableCellFormat>();

		while (cf.hasNext()) {
			CellFormat f = cf.next();

			String id = f.getId();
			String backColour = f.getBackColour();
			String foreColour = f.getForeColour();
			String borderColour = f.getBorderColour();
			String border = f.getBorder();
			String align = f.getAlign();
			String valign = f.getVerticalAlign();

			String fontName = f.getFontName();
			int fontSize = (null == f.getFontSize()) ? DEFAULT_POINT_SIZE : f.getFontSize();
			boolean bold = nullToFalse(f.isBold());
			boolean italic = nullToFalse(f.isItalic());
			String underLine = f.getUnderLine();

			WritableCellFormat cell = new WritableCellFormat();

			if (isNotEmptyorNull(backColour)) {
				Colour c = null;
				try {
					c = fetchStaticObject(Colour.class, backColour);
					cell.setBackground(c);
				} catch (RuntimeException e) {
					e.printStackTrace();
				}
			}// 背景
			if (isNotEmptyorNull(align)) {
				Alignment a = null;
				try {
					a = fetchStaticObject(Alignment.class, align);
					cell.setAlignment(a);
				} catch (RuntimeException e) {
					e.printStackTrace();
				}
			}// 水平对齐方式
			if (isNotEmptyorNull(valign)) {
				VerticalAlignment a = null;
				try {
					a = fetchStaticObject(VerticalAlignment.class, align);
					cell.setVerticalAlignment(a);
				} catch (RuntimeException e) {
					e.printStackTrace();
				}
			}// 垂直对齐方式

			if (isNotEmptyorNull(border)) {
				String[] b = border.split(" ");
				if (b.length == 2) {
					Border bd = fetchStaticObject(Border.class, b[0]);
					BorderLineStyle bs = fetchStaticObject(BorderLineStyle.class, b[1]);

					if (isNotEmptyorNull(borderColour)) {
						Colour c = null;
						try {
							c = fetchStaticObject(Colour.class, borderColour);
							cell.setBorder(bd, bs, c);
						} catch (RuntimeException e) {
							e.printStackTrace();
						}
					} else {
						cell.setBorder(bd, bs);
					}
				}
			}

			WritableFont fontFormat;
			if (isNotEmptyorNull(fontName)) {
				WritableFont.FontName font = null;
				try {
					font = fetchStaticObject(WritableFont.FontName.class, fontName);
				} catch (RuntimeException e) {
					e.printStackTrace();
					font = WritableFont.createFont(fontName);
				}
				fontFormat = new WritableFont(font);
			} else {
				fontFormat = new WritableFont(ARIAL);
			}// 名字
			fontFormat.setPointSize(fontSize);// 大小
			if (bold) {
				fontFormat.setBoldStyle(BOLD);
			} else {
				fontFormat.setBoldStyle(NO_BOLD);
			}// 粗体
			fontFormat.setItalic(italic);// 斜体
			if (isNotEmptyorNull(underLine)) {
				UnderlineStyle us = null;
				try {
					us = fetchStaticObject(UnderlineStyle.class, underLine);
				} catch (RuntimeException e) {
					e.printStackTrace();
					us = UnderlineStyle.NO_UNDERLINE;
				}
				fontFormat.setUnderlineStyle(us);
			}// 下划线

			if (isNotEmptyorNull(foreColour)) {
				Colour c = null;
				try {
					c = fetchStaticObject(Colour.class, foreColour);
				} catch (RuntimeException e) {
					e.printStackTrace();
					c = Colour.BLACK;
				}
				fontFormat.setColour(c);
			}// 颜色

			cell.setFont(fontFormat);
			cell.setWrap(false);
			cellFormat.put(id, cell);
		}
	}

	/**
	 * 处理Title节点
	 * 
	 * @param title
	 * @param sheet
	 * @param row
	 * @return
	 * @throws WriteException
	 */
	private int processTitle(ExcelTitle title, WritableSheet sheet, int row) throws WriteException {
		if (title == null) {
			return row;
		}
		WritableCellFormat cf = exactFormat(title.getCellFormat(), "title");
		WritableCellFeatures ft = new WritableCellFeatures();
		ft.setComment(title.getComment());
		if (null != title.getHeight()) {
			sheet.setRowView(0, title.getHeight());
		}
		int colspan = (null == title.getColspan()) ? 1 : title.getColspan();
		this.writeLabel(sheet, cf, title.getValue(), 0, row, colspan, 1, ft);
		row++;
		return row;
	}

	/**
	 * 处理Head节点
	 * 
	 * @param head
	 * @param sheet
	 * @param row
	 * @return
	 * @throws WriteException
	 * @throws ParseException
	 */
	private int processHead(ExcelHead head, WritableSheet sheet, int row) throws WriteException, ParseException {
		if (head == null) {
			return row;
		}
		List<ExcelRow> rowDate = head.getRow();
		if (null == rowDate || rowDate.isEmpty()) {
			return row;
		}
		WritableCellFormat cf = exactFormat(head.getCellFormat(), "head");
		for (int i = 0; i < rowDate.size(); i++) {
			ExcelRow r = rowDate.get(i);
			if (null != r.getHeight()) {
				sheet.setRowView(row, r.getHeight());
			}
			Iterator<ExcelHCell> c = r.getHcell().iterator();
			for (int j = 0; c.hasNext(); j++) {
				ExcelHCell hcell = c.next();
				processHCell(sheet, hcell, cf, row, j);
			}
			row++;
		}
		return row;
	}

	/**
	 * 处理Body节点
	 * 
	 * @param body
	 * @param sheet
	 * @param row
	 * @return
	 * @throws WriteException
	 * @throws ParseException
	 */
	private int processBody(ExcelBody body, WritableSheet sheet, int row) throws WriteException, ParseException {
		if (body == null) {
			return row;
		}
		List<ExcelRow> rowDate = body.getRow();
		if (rowDate == null || rowDate.isEmpty()) {
			return row;
		}
		WritableCellFormat cf = exactFormat(body.getCellFormat(), "body");
		for (int i = 0; i < rowDate.size(); i++) {
			ExcelRow r = rowDate.get(i);
			if (null != r.getHeight()) {
				sheet.setRowView(row, r.getHeight());
			}
			Iterator<ExcelCell> c = r.getCell().iterator();
			for (int j = 0; c.hasNext(); j++) {
				ExcelCell cell = c.next();
				String type = COLUMN_TYPE.get(j);
				String cfname = cell.getCellFormat();
				if (isNotEmptyorNull(cfname)) {
					processCell(sheet, cell, exactCellFormat(cell.getCellFormat()), type, row, j);
				} else {
					processCell(sheet, cell, cf, type, row, j);
				}
			}
			row++;
		}
		return row;
	}

	/**
	 * 处理Foot节点
	 * 
	 * @param foot
	 * @param sheet
	 * @param row
	 * @return
	 * @throws WriteException
	 * @throws ParseException
	 */
	private int processFoot(ExcelFoot foot, WritableSheet sheet, int row) throws WriteException, ParseException {
		if (foot == null) {
			return row;
		}
		List<ExcelRow> rowDate = foot.getRow();
		if (rowDate == null || rowDate.isEmpty()) {
			return row;
		}
		WritableCellFormat cf = exactFormat(foot.getCellFormat(), "foot");
		for (int i = 0; i < rowDate.size(); i++) {
			ExcelRow r = rowDate.get(i);
			if (null != r.getHeight()) {
				sheet.setRowView(row, r.getHeight());
			}
			Iterator<ExcelCell> c = r.getCell().iterator();
			for (int j = 0; c.hasNext(); j++) {
				ExcelCell cell = c.next();
				String type = COLUMN_TYPE.get(j);
				String cfname = cell.getCellFormat();
				if (isNotEmptyorNull(cfname)) {
					processCell(sheet, cell, exactCellFormat(cell.getCellFormat()), type, row, j);
				} else {
					processCell(sheet, cell, cf, type, row, j);
				}
			}
			row++;
		}
		return row;
	}

	/**
	 * 获取Format信息
	 * 
	 * @param cellFormatName
	 * @param font
	 * @param position
	 * @return
	 */
	private WritableCellFormat exactFormat(String cellFormatName, String position) {
		WritableCellFormat cf;
		if (isNotEmptyorNull(cellFormatName)) {
			cf = this.cellFormat.get(cellFormatName);
		} else {
			cf = CELL_FORMAT.get(position);
		}// SETTING THE CELL FORMAT
		return cf;
	}

	/**
	 * 获取Cell Format信息
	 * 
	 * @param cellFormatName
	 * @param font
	 * @param position
	 * @return
	 */
	private WritableCellFormat exactCellFormat(String cellFormatName) {
		WritableCellFormat cf = null;
		if (isNotEmptyorNull(cellFormatName)) {
			cf = this.cellFormat.get(cellFormatName);
		} // SETTING THE CELL FORMAT
		return cf;
	}

	/**
	 * 处理单元格
	 * 
	 * @param sheet
	 * @param cell
	 * @param cellFormat
	 * @param row
	 * @param j
	 * @throws WriteException
	 * @throws ParseException
	 */
	private void processCell(WritableSheet sheet, ExcelCell cell, WritableCellFormat cellFormat, String type, int row, int j) throws WriteException, ParseException {
		Integer c = (null == cell.getColspan()) ? 1 : cell.getColspan();
		Integer r = (null == cell.getRowspan()) ? 1 : cell.getRowspan();
		WritableCellFeatures features = new WritableCellFeatures();
		features.setComment(cell.getComment());
		if (!isNotEmptyorNull(type)) {
			type = "string";
		}
		if (type.equalsIgnoreCase("date")) {
			writeDate(sheet, cellFormat, cell.getValue(), j, row, c, r, features);
		} else if (type.equalsIgnoreCase("number")) {
			writeNumber(sheet, cellFormat, Double.parseDouble(cell.getValue()), j, row, c, r, features);
		} else {
			writeLabel(sheet, cellFormat, cell.getValue(), j, row, c, r, features);
		}
	}

	/**
	 * 处理单元格
	 * 
	 * @param sheet
	 * @param cell
	 * @param cellFormat
	 * @param row
	 * @param j
	 * @throws WriteException
	 * @throws ParseException
	 */
	private void processHCell(WritableSheet sheet, ExcelHCell cell, WritableCellFormat cellFormat, int row, int j) throws WriteException, ParseException {
		Integer c = (null == cell.getColspan()) ? 1 : cell.getColspan();
		Integer r = (null == cell.getRowspan()) ? 1 : cell.getRowspan();
		WritableCellFeatures features = new WritableCellFeatures();
		features.setComment(cell.getComment());
		writeLabel(sheet, cellFormat, cell.getValue(), j, row, c, r, features);
	}

	/**
	 * 写普通格式数据
	 * 
	 * @param sheet
	 * @param cellFormat
	 * @param labelName
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @throws WriteException
	 */
	private void writeLabel(WritableSheet sheet, WritableCellFormat cellFormat, String labelName, int x, int y, int width, int height, WritableCellFeatures ft)
			throws WriteException {
		if ((x >= 0) && (y >= 0) && (width > 0) && (height > 0)) {
			Label c = null;

			if ((width != 1) || (height != 1)) {
				sheet.mergeCells(x, y, (x + width) - 1, (y + height) - 1);
			}

			c = new Label(x, y, labelName, cellFormat);
			c.setCellFeatures(ft);
			sheet.addCell(c);
		}
	}

	/**
	 * 写数字类型数据
	 * 
	 * @param sheet
	 * @param cellFormat
	 * @param numberData
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @throws WriteException
	 */
	private void writeNumber(WritableSheet sheet, WritableCellFormat cellFormat, double numberData, int x, int y, int width, int height, WritableCellFeatures ft)
			throws WriteException {
		if ((x >= 0) && (y >= 0) && (width > 0) && (height > 0)) {
			jxl.write.Number c = null;
			if ((width != 1) || (height != 1)) {
				sheet.mergeCells(x, y, (x + width) - 1, (y + height) - 1);
			}
			c = new jxl.write.Number(x, y, numberData, cellFormat);
			c.setCellFeatures(ft);
			sheet.addCell(c);
		}
	}

	/**
	 * 写日期类型的数据
	 * 
	 * @param sheet
	 * @param cellFormat
	 * @param date
	 * @param x
	 * @param y
	 * @param width
	 * @param height
	 * @throws WriteException
	 * @throws ParseException
	 */
	private void writeDate(WritableSheet sheet, WritableCellFormat cellFormat, String date, int x, int y, int width, int height, WritableCellFeatures ft) throws WriteException,
			ParseException {
		if ((x >= 0) && (y >= 0) && (width > 0) && (height > 0)) {
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
			DateTime c = new DateTime(x, y, simpleDateFormat.parse(date), cellFormat);
			if ((width != 1) || (height != 1)) {
				sheet.mergeCells(x, y, (x + width) - 1, (y + height) - 1);
			}
			c.setCellFeatures(ft);
			sheet.addCell(c);
		}
	}

	@SuppressWarnings("unchecked")
	private <T> T fetchStaticObject(Class<T> clazz, String name) {
		T t = null;
		try {
			t = (T) clazz.getDeclaredField(name).get(null);
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage() + "不能找类：" + clazz.getName() + "的静态字段：" + name);
		}
		return t;
	}

	/**
	 * 判断字符串是否为null或者空
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isNotEmptyorNull(String str) {
		if (null != str && !"".equals(str)) {
			return true;
		}
		return false;
	}

	public static boolean nullToFalse(Boolean b) {
		if (null == b) {
			return false;
		} else
			return b;
	}

	public void setNumberFormat(String nf) {
		this.numberFormat = nf;
	}

	public void setDateFormat(String df) {
		this.dateFormat = df;
	}

	public static String say() {
		return "I Said ,I'M Allen";
	}

}

使用：

String xml = "FOP.XML";
String xsl = "FOP.XSL";
JAXBExcel helper = new JAXBExcel(new StreamSource(new File(xml)), new StreamSource(new File(xsl)));
File f = new File("C:/a.xls");
OutputStream os = new FileOutputStream(f);
helper.process(os);
os.close();

 其中FOP.xml FOP.xsl文件见附件：

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

文中造词说明：

【目前】------指【2008-10-10】前

【GF】--------指GlassFish

系统环境说明：

【操作系统】-------【Windows XP sp3】或【Windows Server 2003 sp2】，

（没有办法，虽然喜欢linux之类的，但从事项目所限只能如此）

【JDK环境】--------或者说JRE环境，大家记得在装GF的时候会让你选

择一个默认JDK路径的吧。请一定要记住当时的版本号。举个例子，

如果你默认选择了16004，后来你在Eclipse等IDE环境中又追新到16005，

很可能你从IDE中导出的WAR包或EAR包都无法支持。（这么说可能太

简单了，比较GF是面向JavaEE构建的,而JavaEE又涵盖jdk，servlet，jsp，

ejb，jsf等等版本列表，简单的注意JDK的前提是你别的版本不涉及或

可以兼容）。

【联系方式】-------MSN:dinghy@live.com  E-mail:dingis@qq.com

------------第一章 版本路线说明-------------

到目前为止GF发行补丁版本的路线图如下图所示，本图借用自

http://blogs.sun.com/GlassFishForBusiness/entry/sjs_as_9_1_u22

从图中我们可以获知以下信息：

1、GF最早的版本定位 U1 并就此发行了GFv1系列的商业服务器。

2、GFv1在更新到v1p2版本时间附近【Dec.21,2007】，U1开发组做了

重要改进，升级到U2，并就此开始发行GFv2系列的商业服务器。

3、至此GFv1和GFv2的商业版本并存并各自维护发布新的补丁。

GFv1到目前为止，发行了v1p1，v1p2，……，v1p5系列的补丁。

(由于本人接触GF时已经开始U2系列的内容，对于U1的改进不

曾感觉，在此只介绍U2的改进)

       GFv2到目前为止，发行了v2p1，v2p2，v2p3三个系列的补丁。

本次就最新的v2p3补丁进行说明。

4、个人觉得GFv3的开发主要是受约束于Sun的商业推广计划。

为了与Tomcat争夺市场，不得不将GF轻量级化，但又不舍抛弃

之前对于JavaEE版本第一时间实现的承诺，只好用用重写GF以

实现组件式装载。

预计GFv3之后将走类似Eclipse的推广道路，GF Lighter+Upadte

Center加快推广，在实现各取所需的基础上扩大用户群。

在GF框架可以组件形式定制后，其商业服务的订购预计也

将实现组件形式灵活搭配。这样可以降低Sun针对中小企业的

商业维护费用，不必再一篮子捆绑销售那些每年至少要4500$

的服务。这应该就是Sun在GF上的农村包围城市路线。

虽然GFv3进度这么慢，一直预览预览。。。但我挺喜欢这

样的远景规划。

太阳，加油~~~

------------第二章 GFv2 for Business v2p3版本说明-------------

1、引文地址

该版本对应操作系统的发布列表可以参见以下网址：

http://blogs.sun.com/GlassFishForBusiness/entry/sjs_as_9_1_u22

GlassFish For Business: Addressing your Deployment and Business Needs

Saturday Sep 27, 2008

SJS AS 9.1 U2 (GF v2 U2) - Patch 3

SJS AS 9.1 U2 (GF v2 U2) patch 3 is a commercial (Restricted) patch (see

 Overview of GFv2) available as part of Sun's Enterprise Support for GlassFish.

It was released on September 11th, 2008.

2、版本概述

包含了Solaris SPARC， Solaris x86， Linux，Windows and AIX，一共

5个版本，并分为基于Package和基于File两种patch类型，在基于File的

Patch中又根据是否包含 HADB模块分为两种。

我一般下载的是  基于File且不包含HADB 的Windows版本，访问的是：

http://sunsolve.sun.com/search/document.do?assetke

y=1-21-128650-05

关于HADB功能的使用介绍。可以去查一下。或者等我下面的文章细说。

其中可以看到Patch大概是80多M，而且又根据是否有Sun公司的数字签

名Digital Signature，分为Signed和Unsigned。

Signed Patch的优点呢，就和一个文件的md5码差不多，你可以确认是不

是原始下载文件。具体你可以去执行一下Java命令 jarsigner。

呵呵，还是没有在HP UX的版本。看来Sun与HP的针对GF的商业合作，

谈判不太顺利。

3、v2系列修正bug列表回顾待续。

      v2系列发行的版本从u2以来主要有三个patch,分别是:

2.1-----128650-05(9.1U2P03) 14项更新

2.2-----128650-04(9.1U2P02) 18项更新

2.3-----128650-03(9.1U2P01) 14项更新

      具体bug更新内容见文章后面的附录,我比较关注的内存泄露检测和自动关

闭链接问题,似乎是解决了.但是可恶的Sun公司不让我们去下载…P02之前的版本可

以从sun的官网上下载到.

    【下面的内容见下篇吧，发不上了】

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

MyEclipse_6.0.1GA_E3.3.1_FullStackInstaller.exe
URL: http://downloads.myeclipseide.com/downloads/products/eworkbench/6.0.1GA/MyEclipse_6.0.1GA_E3.3.1_FullStackInstaller.exe
Size: 244.81 MB


MyEclipse_6.0.1GA_E3.3.1_Installer.exe
URL: http://downloads.myeclipseide.com/downloads/products/eworkbench/6.0.1GA/MyEclipse_6.0.1GA_E3.3.1_Installer.exe
Size: 176.33 MB


eclipse-SDK-3.3.1-win32.zip
URL: http://download.actuatechina.com/eclipse/eclipse/downloads/drops/R-3.3.1-200709211145/eclipse-SDK-3.3.1-win32.zip

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

<script type="text/javascript">
    // Dojo configuration
    djConfig = {
        baseRelativePath: "struts/dojo", <<:::::::::::::::就是要改这里。
        isDebug: false,
        bindEncoding: "UTF-8"
    };
</script>
<script type="text/javascript" src="struts/dojo/dojo.js"></script>    <<:::::::::::::::::::::::::::::还有这里
<script type="text/javascript">
dojo.require("dojo.io.BrowserIO");
dojo.require("dojo.event.topic");
dojo.hostenv.setModulePrefix('struts', 'struts');
dojo.widget.manager.registerWidgetPackage('struts.widget');
dojo.require("struts.widget.Bind");
dojo.require("struts.widget.BindDiv");
dojo.require("struts.widget.BindAnchor");
dojo.require("struts.widget.ComboBox");
dojo.require("struts.widget.StrutsTimePicker")
</script>

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

Struts标记分为(5组)
JSP里学习过标准标签库与自定义标签，它的原理是一个JAVA类代码实现的，通过页面的

<%@ taglib  uri="/WEB-INF/struts-html.tld" prefix="html" %>

 来导入相应的配置文件，使用别名prefix即可调用标签库设定的标记
Html  struts-html.tld
Bean   struts-bean.tld
Logic   struts-logic.tld
Tiles   struts-tiles.tld
Nested  struts-nested.tld
红字为Struts中重要掌握的标签内容。一般JSP页面都导入红字相应的标签

上一笔记中只介绍了HTML表单的标签与BEAN中Write的一些简单的使用.接下来详细介绍bean及logic里面的标签元素
BEAN

<bean:define/>  定义变量
id=变量名
value=变量值
toScope=存储范围
name=存储作用域中的键名
property=属性
type=变量类型

<bean:define id="username" value="张三" toScope="request"/> 
username:<bean:write name="username" scope="request"/> 

 
<bean:write/> 输出变量值
<bean:write>
name=变量名
filter=是否过滤html
format=输出格式
property 属性名字
__________________________________________________________________________________
例如要输出对象时，必须先给定name为对象的别名，property属性的名称。
如：User对象中有Name属性

Request.setAttribute(“user”,UserObj); 
<bean :write name = “user” property=“name”/> 
request.setAttribute("date",new java.util.Date() );  --定义一个时间对象 
<bean:write name="date"/><br />   --默认输出为Mon Jul 09 21:44:06 CST 2007 
<bean:write name="date" format="yyyy-MM-dd"/><br />              2007-07-09 
<bean:write name="date" format="yyyy年MM月dd日"/><br />         2007年07月09日 

 __________________________________________________________________________________
<bean:size/> 计算集合长度
<bean:size>
id=变量名
name=存储作用域中的键名，该键名对应一个集合
------------------------------------------