zx_bing

一、为 SQL 启用远程连接

1. 单击“开始”，依次指向“程序”、“Microsoft SQL Server 2005”和“配置工具”，然后单击“SQL Server 外围应用配置器”。
2. 在“SQL Server 2005 外围应用配置器”页上，单击“服务和连接的外围应用配置器”。
3. 在“服务和连接的外围应用配置器”页上，展开“数据库引擎”，依次单击“远程连接”和“本地连接和远程连接”，单击适用于您的环境的相应协议，然后单击“应用”。

注意：请在接收到以下消息时单击“确定”：
直到重新启动数据库引擎服务后，对连接设置所做的更改才会生效。
4. 在“服务和连接的外围应用配置器”页上，展开“数据库引擎”，依次单击“服务”和“停止”，等待 MSSQLSERVER 服务停止，然后单击“启动”以重新启动 MSSQLSERVER 服务。

二、启用 SQL Server Browser 服务

1. 单击“开始”，依次指向“程序”、“Microsoft SQL Server 2005”和“配置工具”，然后单击“SQL Server 外围应用配置器”。
2. 在“SQL Server 2005 外围应用配置器”页上，单击“服务和连接的外围应用配置器”。
3. 在“服务和连接的外围应用配置器”页上，单击“SQL Server Browser”，在“启动类型”中单击“自动”选项，然后单击“应用”。

注意：在单击“自动”选项后，每次启动 Microsoft Windows 时将自动启动 SQL Server Browser 服务。
4. 单击“启动”，然后单击“确定”。

三、在 Windows 防火墙中为SQL Server 2005 创建例外

1. 在 Windows 防火墙中，单击“例外”选项卡，然后单击“添加程序”。
2. 在“添加程序”窗口中，单击“浏览”。
3. 单击 C:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\Binn\sqlservr.exe 可执行程序，单击“打开”，然后单击“确定”。

注意：上述路径可能会根据 SQL Server 2005 的安装位置而不同。

四、在 Windows 防火墙中为 SQL Server Browser 服务创建例外

1. 在 Windows 防火墙中，单击“例外”选项卡，然后单击“添加程序”。
2. 在“添加程序”窗口中，单击“浏览”。
3. 单击 C:\Program Files\Microsoft SQL Server\90\Shared\sqlbrowser.exe 可执行程序，单击“打开”，然后单击“确定”。

注意：上述路径可能会根据 SQL Server 2005 的安装位置而不同。

五、远程连接端口设置(很关键的一步，很多方法只讲了一到四步，却没有讲到第五步)

1、在服务器上打开SQL Server Configuration Manager。选择SQL Server配置治理器->SQL Server 2005网络配置->MSSQLSERVER的协议->TCP/IP，在弹出对话框中选择IP地址->IPALL->TCP端口，设置为可用端口。(如果默认的1433端口老是连接不上，你就设置为你确认已经打开的端口试试，如21端口等)

2、在“服务和连接的外围应用配置器”页上，展开“数据库引擎”，依次单击“服务”和“停止”，等待 MSSQLSERVER 服务停止，然后单击“启动”以重新启动 MSSQLSERVER 服务。

六、测试连接

1、打开SQL2005登陆界面，输入服务器IP和用户名及密码。
如：
服务器名称：192.168.1.200,21
用户名：sa
密码：sa
点连接，结果连接成功。
PS:上面的服务器名称中的,21中的21第五步中第1步中设置的IPALL中的TCP端口

Hibernate映射类型	java类型	标准SQL类型
integer	java.lang.Integer	integer
long	java.lang.Long	bigint
short	java.lang.Short	smallint
float	java.lang.Float	float
double	java.lang.Float	double
big_decimal	java.math.BigDecimal	numeric
character	java.lang.String	char(1)
string	java.lang.String	varchar
byte	byte或java.lang.Byte	tinyint
boolean	boolean或java.lang.Boolean	bit
yes_no	boolean或java.lang.Boolean	char(1)('Y'/'N')
true_false	boolean或java.lang.Boolean	char(1)('Y'/'N')
date	java.util.Date或java.sql.Date	date
time	java.util.Date或java.sql.Time	time
timestamp	java.util.Date或java.sql.timestamp	timestamp
calendar	java.util.Calendar	timestamp
calendar_date	java.util.Calendar	date
binary	byte[]	varbinary或blob
text	java.lang.String	clob
serializable	java.io.Serializable实例	varbinary或blob
clob	java.sql.Clob	clob
blob	java.sql.Blob	varbinary或blob
class	java.lang.Class	varchar
locale	java.util.Locale	varchar
timezone	java.util.TimeZone	varchar
currency	java.util.Currency	varchar

关于lazy机制：

延迟初始化错误是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略，那么必须当代理类实例或代理集合处于持久化状态（即处于Session范围内）时，才能初始化它。如果在游离状态时才初始化它，就会产生延迟初始化错误。

下面把Customer.hbm.xml文件的<class>元素的lazy属性设为true，表示使用延迟检索策略：

<class name="mypack.Customer" table="CUSTOMERS" lazy="true">

当执行Session的load()方法时，Hibernate不会立即执行查询CUSTOMERS表的select语句，仅仅返回Customer类的代理类的实例，这个代理类具由以下特征：

（1） 由Hibernate在运行时动态生成，它扩展了Customer类，因此它继承了Customer类的所有属性和方法，但它的实现对于应用程序是透明的。
（2） 当Hibernate创建Customer代理类实例时，仅仅初始化了它的OID属性，其他属性都为null，因此这个代理类实例占用的内存很少。
（3）当应用程序第一次访问Customer代理类实例时（例如调用customer.getXXX()或customer.setXXX()方法）， Hibernate会初始化代理类实例，在初始化过程中执行select语句，真正从数据库中加载Customer对象的所有数据。但有个例外，那就是当应用程序访问Customer代理类实例的getId()方法时，Hibernate不会初始化代理类实例，因为在创建代理类实例时OID就存在了，不必到数据库中去查询。

提示：Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具，它能够在程序运行时动态生成扩展 Java类或者实现Java接口的代理类。关于CGLIB的更多知识，请参考：http://cglib.sourceforge.net/。

以下代码先通过Session的load()方法加载Customer对象，然后访问它的name属性：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getName();
tx.commit();

在运行session.load()方法时Hibernate不执行任何select语句，仅仅返回Customer类的代理类的实例，它的OID为1，这是由load()方法的第二个参数指定的。当应用程序调用customer.getName()方法时，Hibernate会初始化Customer代理类实例，从数据库中加载Customer对象的数据，执行以下select语句：

select * from CUSTOMERS where ID=1;
select * from ORDERS where CUSTOMER_ID=1;

当<class>元素的lazy属性为true，会影响Session的load()方法的各种运行时行为，下面举例说明。

1．如果加载的Customer对象在数据库中不存在，Session的load()方法不会抛出异常，只有当运行customer.getName()方法时才会抛出以下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
mypack.Customer

2．如果在整个Session范围内，应用程序没有访问过Customer对象，那么Customer代理类的实例一直不会被初始化，Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();

由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化，因此在执行customer.getName()方法时，Hibernate会抛出以下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed

由此可见，Customer代理类的实例只有在当前Session范围内才能被初始化。

3．net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例，isInitialized()方法用于判断代理类实例是否已经被初始化。例如：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
if(!Hibernate.isInitialized(customer))
Hibernate.initialize(customer);
tx.commit();
session.close();
customer.getName();

以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例，因此当Session关闭后，可以正常访问Customer游离对象。

4．当应用程序访问代理类实例的getId()方法时，不会触发Hibernate初始化代理类实例的行为，例如：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getId();
tx.commit();
session.close();
customer.getName();

当应用程序访问customer.getId()方法时，该方法直接返回Customer代理类实例的OID值，无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例，因此当Session关闭后再执行customer.getName()方法， Hibernate会抛出以下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed


解决方法：

由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的session已关闭掉,就会产生种错误.
在做一对多时，有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在<many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫

failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed

此异常解决方案请察看本人博客（http://hi.baidu.com/kekemao1）的Hibernate异常中的《failed to lazily initialize a collection of role异常》

?
解决方法:在web.xml中加入
<filter>
    <filter-name>hibernateFilter</filter-name>
    <filter-class>
     org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
    </filter-class>
</filter
<filter-mapping>
    <filter-name>hibernateFilter</filter-name>
    <url-pattern>*.do</url-pattern>
</filter-mapping>
就可以了;
参考了:
Hibernate与延迟加载：

Hibernate对象关系映射提供延迟的与非延迟的对象初始化。非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一起读取出来。这有时会导致成百的（如果不是成千的话）select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候，经常会导致整个数据库都在初始化的阶段被读出来了。当然，你可以不厌其烦地检查每一个对象与其他对象的关系，并把那些最昂贵的删除，但是到最后，我们可能会因此失去了本想在ORM工具中获得的便利。


一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的，而且只进行了很少的数据库操作请求，因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来，所有的数据库逻辑，包括打开或关闭会话，都不能在应用层出现。最常见的是，一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式，将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效，但是在大的系统中，这是一个严重的设计缺陷，妨碍了系统的可扩展性。

在Web层进行延迟加载

幸运的是，Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种方便的解决方法。对那些不熟悉Spring与Hibernate集成使用的人，我不会在这里讨论过多的细节，但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例，Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中，而Filter在Spring之前运行并被配置在web.xml中。不管用哪个，他们都在请求将当前会话与当前（数据库）线程绑定时打开Hibernate会话。一旦已绑定到线程，这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了，Hibernate会话会在Filter的doFilter方法或者Interceptor的postHandle方法中被关闭。下面是每个组件的配置示例：



Interceptor的配置:


<beans>
<bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<ref bean="openSessionInViewInterceptor"/>
</list>
</property>
<property name="mappings">

</bean>

<bean name="openSessionInViewInterceptor"
class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
<property name="sessionFactory"><ref bean="sessionFactory"/></property>
</bean>
</beans>

Filter的配置


<web-app>

<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</filter-class>
</filter>

<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*. spring </url-pattern>
</filter-mapping>

</web-app>


实现Hibernate的Dao接口来使用打开的会话是很容易的。事实上，如果你已经使用了Spring框架来实现你的Hibernate Dao,很可能你不需要改变任何东西。方便的HibernateTemplate公用组件使访问数据库变成小菜一碟，而DAO接口只有通过这个组件才可以访问到数据库。下面是一个示例的DAO：


public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {

public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product.class, productId);
}

public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}

public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}


在业务逻辑层中使用延迟加载

即使在视图外面，Spring框架也通过使用AOP 拦截器 HibernateInterceptor来使得延迟加载变得很容易实现。这个Hibernate 拦截器透明地将调用配置在Spring应用程序上下文中的业务对象中方法的请求拦截下来，在调用方法之前打开一个Hibernate会话，然后在方法执行完之后将会话关闭。让我们来看一个简单的例子，假设我们有一个接口BussinessObject：


public     interface    BusinessObject     {
public     void    doSomethingThatInvolvesDaos();
}
类BusinessObjectImpl实现了BusinessObject接口:

public     class    BusinessObjectImpl    implements    BusinessObject     {
public     void    doSomethingThatInvolvesDaos()     {
//    lots of logic that calls
//    DAO classes Which access
//    data objects lazily 
} 
} 



通过在Spring应用程序上下文中的一些配置，我们可以让将调用BusinessObject的方法拦截下来，再令它的方法支持延迟加载。看看下面的一个程序片段：



<beans>
<bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
<property name="someDAO"><ref bean="someDAO"/></property>
</bean>
<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target"><ref bean="businessObjectTarget"/></property>
<property name="proxyInterfaces">
<value>com.acompany.BusinessObject</value>
</property>
<property name="interceptorNames">
<list>
<value>hibernateInterceptor</value>
</list>
</property>
</bean>
</beans>

当businessObject被调用的时候，HibernateInterceptor打开一个Hibernate会话，并将调用请求传递给BusinessObjectImpl对象。当BusinessObjectImpl执行完成后，HibernateInterceptor透明地关闭了会话。应用层的代码不用了解任何持久层逻辑，还是实现了延迟加载。


在单元测试中测试延迟加载

最后，我们需要用J-Unit来测试我们的延迟加载程序。我们可以轻易地通过重写TestCase类中的setUp和tearDown方法来实现这个要求。我比较喜欢用这个方便的抽象类作为我所有测试类的基类。


public abstract class MyLazyTestCase extends TestCase {

private SessionFactory sessionFactory;
private Session session;

public void setUp() throws Exception {
super.setUp();
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
session = SessionFactoryUtils.getSession(sessionFactory, true);
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));

}

protected Object getBean(String beanName) {
//Code to get objects from Spring application context
}

public void tearDown() throws Exception {
super.tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}

--------------------------------------------------------------
--------------------------------------------------------------

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.isoftstone.lms.model">
	<class name="Order" table="sv_order" >
		<id name="orderId" column="sv_order_id" type="string">
			<generator class="sequence">
				<param name="sequence">SEQ_ORDERID</param>
			</generator>
		</id>
		
		many-to-one name="style" column="sv_style_id" lazy="false" />
		<many-to-one name="state" column="sv_state_id"  lazy="false"/>
		<many-to-one name="client" column="sv_client_id" lazy="false" />
		<many-to-one name="baseOrder" column="sv_order_baseid"  lazy="false"/>
		<property name="orderNo" column="sv_order_orderno" type="long" />
		<property name="createDate" column="sv_order_createdate" type="date" />
		<property name="sendDate" column="sv_order_senddate" type="string" />
		<property name="sendAddress" column="sv_order_sendAddress" type="string" />
		<property name="accepter" column="sv_order_accepter" type="string" />
		<property name="postNo" column="sv_order_postNo" type="string" />
		<property name="phone" column="sv_order_phone" type="string" />
		<property name="totalMoney" column="sv_order_totalmoney" type="double" />
		<property name="isinvoice" column="sv_order_isinvoice" type="int" />
		<property name="remark" column="sv_order_remark" type="string" />
		
		<set name="orderGoodss" inverse="true" lazy="extra" cascade="all">
			<key column="sv_order_id"/>
			<one-to-many class="OrderGoods"/>
		</set>
	</class>
</hibernate-mapping>

[color=red]

		<many-to-one name="style" column="sv_style_id" lazy="false" />
		<many-to-one name="state" column="sv_state_id"  lazy="false"/>
		<many-to-one name="client" column="sv_client_id" lazy="false" />
		<many-to-one name="baseOrder" column="sv_order_baseid"  lazy="false"/>

[/color]

1. public List<Order> getClientOrder(String clientId) { 
2.  
3.         Session session = null; 
4.         List<Order> orderList = null; 
5.         try { 
6.             session = HibernateUtil.getSession(); 
7.             session.beginTransaction(); 
8.             orderList = session.createQuery("from Order o where o.client.clientId = ?") 
9.                                 .setParameter(1,clientId) 
10.                                 .list(); 
11.             session.getTransaction().commit(); 
12.         } catch (Exception e) { 
13.             e.printStackTrace(); 
14.             session.getTransaction().rollback(); 
15.         } finally { 
16.             HibernateUtil.closeSession(session); 
17.         } 
18.  
19.         return orderList; 
20.     } 

1. public List<Client> searchClients(String clientName, String tel, 
2.             String identityNo) { 
3.  
4.         StringBuffer sb = new StringBuffer("from Client c where 1=1"); 
5.          
6.         if(clientName != null && !"".equals(clientName) ){ 
7.             sb.append("and c.name like '%" + clientName + "%'"); 
8.         } 
9.         if(tel != null && !"".equals(tel)){ 
10.             sb.append("and c.tel = " + tel); 
11.         } 
12.         if(identityNo != null && !"".equals(identityNo)){ 
13.             sb.append("and c.identityNo = " + identityNo); 
14.         } 
15.         return clientDao.searchClients(sb.toString()); 
16. } 

<input name="username" value="" length="12" maxlengthd="12"/>
数据库里面username vachar2(12)

这个输入框要求用JAVASCRIPT去验证不能超过12个数字或英文或数字英文组合，还要求不能超过6个汉字,还要验证汉字和字母，数字的组合

如：用户名1999(就可以)，麦克斯韦1999(就不行)

因为数据库里面要求的长度是12，一个汉字就占两个，但是在页面可以输入12个汉字
请用JAVASCRIPT写出你的解决方案？

three.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <title>index.html</title>
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="this is my page">
        <meta http-equiv="content-type" content="text/html; charset=GBK">
        <script type="text/javascript">
        var xmlhttp;
        function loadXMLDoc(valueFromSelect1){
            var url = "three.jsp?valueFromSelect=" + valueFromSelect1 + "&" + Math.random();
            alert(url);
            xmlhttp=null;
            if (window.XMLHttpRequest){
              xmlhttp=new XMLHttpRequest();
            }
            else if (window.ActiveXObject){
              xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
            }
            if (xmlhttp!=null){
              xmlhttp.onreadystatechange=updatePage;
              xmlhttp.open("GET",url,true);
              xmlhttp.send(null);
            }
            else{
              alert("Your browser does not support XMLHTTP.");
            }
        }
        
        function state_Change(){
            if (xmlhttp.readyState==4){
                if (xmlhttp.status==200){
                    updatePage();
                }
                else{
                    alert("Problem retrieving XML data");
                }
            }
        }
        
        function updatePage(){            
            // 清空select2
            while(select2.options[0] != null){
                select2.options[0] = null;
            }
            
            // 设置select2
            var xmlDoc = xmlhttp.responseXML;
            alert(xmlDoc);
            var labelValueBeanElements = xmlDoc.getElementsByTagName("labelValueBean");
          
            for (var i = 0; i < labelValueBeanElements.length; i++){
                var entityValue = xmlDoc.getElementsByTagName("value")[i].childNodes[0].nodeValue;
                var entityLabel = xmlDoc.getElementsByTagName("label")[i].childNodes[0].nodeValue;
                select2.options[i] = new Option(entityLabel,entityValue,false,false);
            }
        }
        </script>
    </head>

    <body>
        select1:
        <select id="select1" onchange="loadXMLDoc(this.value)">
            <option value="1">1</option>
            <option value="2">2</option>
        </select>
        <br/>
        select2:
        <select id="select2">
        </select>
        <input type="button" value="显示select2的值" onclick="alert(select2.value)">
    </body>
</html>

three.jsp

1. function selectall()  
2. {  
3.     //获取页面上所有的输入元素 
4.     var a = document.getElementsByTagName("input");  
5.     //如果全选按钮按上 
6.     if(document.getElementById("quanxuanbutton").checked == true) 
7.     { 
8.         //循环是checkbox类型的，就设置为true 
9.         for (var i=0; i<a.length; i++) 
10.         { 
11.             if (a[i].type == "checkbox") 
12.             { 
13.                 a[i].checked =true; 
14.             } 
15.         }        
16.          
17.     }else{ //如果全选按钮没有按上 
18.       for (var i=0; i<a.length; i++) 
19.         { 
20.             if (a[i].type == "checkbox") 
21.             { 
22.                  
23.                 a[i].checked =false; 
24.             } 
25.         }   
26.     } 
27. }  

1. //省市联动  
2. var c_cigy = ''; 
3. //记录第二个列表id，以备回调函数用 
4. var cityItemName = ''; 
5.  
6. function  changeCityOyp(province,city,relateItemName) { 
7.     ServerDwrUtil.getCityList(province.value,setCityOption); 
8.     //记录二级下拉的 id relateItemName 供回调函数使用 
9.     cityItemName = relateItemName; 
10.     // 中国 则 二级下拉 不能选择 
11.     if(province.value == '0001') { 
12.         document.getElementById(cityItemName).disabled = true; 
13.     } else { 
14.         document.getElementById(cityItemName).disabled = false; 
15.     } 
16.     //省份在一个单元格里，省份前面有个input输入框,得到input对象，再把省份传进去 
17.     var provinceInput  = province.parentNode.firstChild; 
18.     //如果省份为空，则单元格为空 
19.     if (province.value == '') { 
20.         provinceInput.value = ''; 
21.         return; 
22.     } 
23.     provinceInput.value = province.options[province.selectedIndex].text; 
24.      
25. } 
26. // 回调函数 args返回的是list.add(Map) map中{id}，经过 spring配置 对于一些特例返回的Class，且dwr不能识别的， 
27. //</dwr:configuration> 
28. // 设置二级下拉列表 
29. function setCityOption (args) { 
30.     alert(args.toString()); 
31.     DWRUtil.removeAllOptions(cityItemName); 
32.     DWRUtil.addOptions(cityItemName, [ "" ]); 
33.     //id和name怎么确保的   args{[id:xxx,name:yyy],[id:xxx,name:yyyy]} 
34.     DWRUtil.addOptions(cityItemName, args, "id", "name"); 
35. } 

1. 获取显示的汉字 
2.  
3. document.getElementById("bigclass").options[window.document.getElementById("bigclass").selectedIndex].text 
4.  
5. 获取数据库中的id 
6.  
7. window.document.getElementById("bigclass").value 
8.  
9. 获取select组分配的索引id 
10.  
11. window.document.getElementById("bigclass").selectedIndex 
12.  
13.  
14. 例子： 
15.  
16. <select name="bigclass" id="bigclass" onChange="javascript:updatePage2();"> 
17. <option value="" selected="selected">ajax实验</option> 
18. <option value="4">我适宜市哈</option> 
19. </select> 
20.  
21.  
22. 使用 
23. document.getElementById("bigclass").options[window.document.getElementById("bigclass").selectedIndex].text 
24. 的结果是：我适宜市哈 
25.  
26. 使用 
27. window.document.getElementById("bigclass").value 
28. 的结果是：4 
29.  
30. 使用 
31. window.document.getElementById("bigclass").selectedIndex 
32. 的结果是：1