1，使用Spring 的 ActionSupport
2, 使用Spring 的 DelegatingRequestProcessor 类。
3，全权委托。

无论用那种方法来整合第一步就是要为struts来装载spring的应用环境。 就是在 struts 中加入一个插件。
struts-config.xml中

 <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
 </plug-in>

spring 的配置文件被作为参数配置进来。这样可以省略对web.xml 文件中的配置。确保你的applicationContext.xml 在WEB-INF目录下面

1，使用Spring的ActionSupport .
Spring 的ActionSupport 继承至 org.apache.struts.action.Action
ActionSupport的子类可以或得 WebApplicationContext类型的全局变量。通过getWebApplicationContext()可以获得这个变量。

这是一个 servlet 的代码：
public class LoginAction extends org.springframework.web.struts.ActionSupport {
 
 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
                //获得  WebApplicationContext  对象             
  WebApplicationContext ctx = this.getWebApplicationContext();
  
  LoginDao dao = (LoginDao) ctx.getBean("loginDao");
  User u = new User();
  
  u.setName(loginForm.getName());
  u.setPwd(loginForm.getPwd());
  
  
  if(dao.checkLogin(u)){
   return mapping.findForward("success");
  }else{
   return  mapping.findForward("error");
  }
  
 }
}

applicationContext.xml 中的配置
<beans>
 <bean id="loginDao" class="com.cao.dao.LoginDao"/>
</beans>

这中配置方式同直接在web.xml文件配置差别不大。注意：Action继承自 org.springframework.web.struts.ActionSupport 使得struts和spring耦合在一起。
但实现了表示层和业务逻辑层的解耦(LoginDao dao = (LoginDao) ctx.getBean("loginDao"))。

2,使用Spring 的 DelegatingRequestProcessor 类
DelegatingRequestProcessor  继承自 org.apache.struts.action.RequestProcessor 并覆盖了里面的方法。
sturts-config.xml  中  <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/> 通过 <controller >来替代
                        org.apache.struts.action.RequestProcessor 的请求处理。

public class LoginAction extends Action {
 //利用spring来注入这个对象。
 private LoginDao dao ;
 
 public void setDao(LoginDao dao) {
  System.out.println("执行注入");
  this.dao = dao;
 }

 public LoginDao getDao() {
  return dao;
 }

 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
  //这样一改这行代码似乎没有必要了。
  //WebApplicationContext ctx = this.getWebApplicationContext();
  //LoginDao dao = (LoginDao) ctx.getBean("loginDao");
 
  User u = new User();
  
  u.setName(loginForm.getName());
  u.setPwd(loginForm.getPwd());
  
  //直接用dao来调用spring会将这个对象实例化。
  if(dao.checkLogin(u)){
   return mapping.findForward("success");
  }else{
   return  mapping.findForward("error");
  }
  
 }
}
这里的。
LoginAction extends Action 说明 struts 每有和spring 耦合。
看一下
applicationContext.xml 中的配置。
<beans>
 <bean id="loginDao" class="com.cao.dao.LoginDao"/>
 
 <bean name="/login" class="com.cao.struts.action.LoginAction">
  <property name="dao">
   <ref local="loginDao"/>
  </property>
 </bean>
</beans>

这里 name="/login" 与struts 中的path匹配
    class="com.cao.struts.action.LoginAction" 与struts 中的type匹配

还要为 LoginAction 提供必要的setXXX方法。 获得ApplicationCotext和依赖注入的工作都在DelegatingRequestProcessor中完成。

3，全权委托：
Action 的创建和对象的依赖注入全部由IOC容器来完成。 使用Spring的DelegatingAcionProxy来帮助实现代理的工作
org.springframework.web.struts.DelegatingActiongProxy继承于org.apache.struts.action.Action .

全权委托的配置方式同 方式 2 类似 (applcationContext.xml文件的配置和 Action类的实现方式相同)。
<struts-config>
  <data-sources />
  <form-beans >
    <form-bean name="loginForm" type="com.cao.struts.form.LoginForm" />

  </form-beans>

  <global-exceptions />
  <global-forwards />
 <action-mappings >
    <!-- type指向的是spring 的代理类 -->
    <action
      attribute="loginForm"
      input="login.jsp"
      name="loginForm"
      path="/login"
      scope="request"

      type="org.springframework.web.struts.DelegatingActionProxy" >
     
      <forward name="success" path="/ok.jsp" />
      <forward name="error" path="/error.jsp" />
    </action>
 
 </action-mappings>
 
  
  <message-resources parameter="com.cao.struts.ApplicationResources" />

 <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
 </plug-in>

</struts-config>
不同之处
1， <action>中 type指向的是spring 的代理类

2， 去掉struts-config.xml中 <controller >

三种整和方式中我们优先选用 全权委托的方式。
理由：
1，第一种使得过多的耦合了Spring和Action .
2,RequestProcessor类已经被代理 如果要再实现自己的实现方式（如：编码处理）怕有点麻烦。

总结一下：
整合工作中的步骤：
1，修改struts-config.xml  
2, 配置applicationContext.xml
3, 为Action添加get/set方法 来获得依赖注入的功能。

本文转自：http://blog.csdn.net/caoyinghui1986/archive/2008/06/02/2501914.aspx

隔离级别定义了事务与事务之间的隔离程度。

隔离级别与并发性是互为矛盾的：隔离程度越高，数据库的并发性越差；隔离程度越低，数据库的并发性越好。

ANSI/ISO SQ92标准定义了一些数据库操作的隔离级别：

• 未提交读（read uncommitted）
• 提交读（read committed）  
• 重复读（repeatabe read）  
• 序列化（seriaizabe）

通过一些现象，可以反映出隔离级别的效果。这些现象有：

• 更新丢失（ost update）：当系统允许两个事务同时更新同一数据是，发生更新丢失。  
• 脏读（dirty read）：当一个事务读取另一个事务尚未提交的修改时，产生脏读。
• 非 重复读（nonrepeatabe read）：同一查询在同一事务中多次进行，由于其他提交事务所做的修改或删除，每次返回不同的结果集，此时发生非重复读。(A transaction rereads data it has previousy read and finds that another committed transaction has modified or deeted the data. )
• 幻 像（phantom read）：同一查询在同一事务中多次进行，由于其他提交事务所做的插入操作，每次返回不同的结果集，此时发生幻像读。(A transaction reexecutes a query returning a set of rows that satisfies a search condition and finds that another committed transaction has inserted additiona rows that satisfy the condition. )

下面是隔离级别及其对应的可能出现或不可能出现的现象

ORACE的隔离级别

ORACE提供了SQ92标准中的read committed和seriaizabe，同时提供了非SQ92标准的read-ony。

read committed：

• 这是ORACE缺省的事务隔离级别。
• 事务中的每一条语句都遵从语句级的读一致性。
• 保证不会脏读；但可能出现非重复读和幻像。

seriaizabe：（串行执行事务，并发性最小）

• 简单地说，seriaizabe就是使事务看起来象是一个接着一个地顺序地执行。
• 仅仅能看见在本事务开始前由其它事务提交的更改和在本事务中所做的更改。
• 保证不会出现非重复读和幻像。
• Seriaizabe隔离级别提供了read-ony事务所提供的读一致性（事务级的读一致性），同时又允许DM操作。

如果有在seriaizabe事务开始时未提交的事务在seriaizabe事务结束之前修改了seriaizabe事务将要修改的行并进行了提交，则seriaizabe事务不会读到这些变更，因此发生无法序列化访问的错误。（换一种解释方法：只要在seriaizabe事务开始到结束之间有其他事务对seriaizabe事务要修改的东西进行了修改并提交了修改，则发生无法序列化访问的错误。）

If a serializable transaction contains data manipulation language (DML) that attempts to update any resource that may have been updated in a transaction uncommitted at the start of the serializable transaction, （并且修改在后来被提交而没有回滚），then the DML statement fails. 返回的错误是ORA-08177: Cannot serialize access for this transaction。

ORACE在数据块中记录最近对数据行执行修改操作的N个事务的信息，目的是确定本事务开始时，是否存在未提交的事务修改了本事务将要修改的行。具体见英文：

Oracle permits a serializable transaction to modify a data row only if it can determine that prior changes to the row were made by transactions that had committed when the serializable transaction began.

To make this determination efficiently, Oracle uses control information stored in the data block that indicates which rows in the block contain committed and uncommitted changes. In a sense, the block contains a recent history of transactions that affected each row in the block. The amount of history that is retained is controlled by the INITRANS parameter of CREATE TABLE and ALTER TABLE. Under some circumstances, Oracle may have insufficient history information to determine whether a row has been updated by a "too recent" transaction. This can occur when many transactions concurrently modify the same data block, or do so in a very short period. You can avoid this situation by setting higher values of INITRANS for tables that will experience many transactions updating the same blocks. Doing so will enable Oracle to allocate sufficient storage in each block to record the history of recent transactions that accessed the block.

The INITRANS Parameter：Oracle stores control information in each data block to manage access by concurrent transactions. Therefore, if you set the transaction isolation level to serializable, you must use the ALTER TABLE command to set INITRANS to at least 3. This parameter will cause Oracle to allocate sufficient storage in each block to record the history of recent transactions that accessed the block. Higher values should be used for tables that will undergo many transactions updating the same blocks.

read-ony：

• 遵从事务级的读一致性，仅仅能看见在本事务开始前由其它事务提交的更改。
• 不允许在本事务中进行DM操作。
• read ony是seriaizabe的子集。它们都避免了非重复读和幻像。区别是在read ony中是只读；而在seriaizabe中可以进行DM操作。
• Export with CONSISTENT = Y sets the transaction to read-ony.

read committed和seriaizabe的区别和联系：

事务1先于事务2开始，并保持未提交状态。事务2想要修改正被事务1修改的行。事务2等待。如果事务1回滚，则事务2（不论是read committed还是seriaizabe方式）进行它想要做的修改。如果事务1提交，则当事务2是read committed方式时，进行它想要做的修改；当事务2是seriaizabe方式时，失败并报错“Cannot seriaize access”，因为事务2看不见事务1提交的修改，且事务2想在事务1修改的基础上再做修改。

即seriaizabe不允许存在事务嵌套

具体见英文：

Both read committed and serializable transactions use row-level locking, and both will wait if they try to change a row updated by an uncommitted concurrent transaction. The second transaction that tries to update a given row waits for the other transaction to commit or roll back and release its lock. If that other transaction rolls back, the waiting transaction (regardless of its isolation mode) can proceed to change the previously locked row, as if the other transaction had not existed. However, if the other (blocking) transaction commits and releases its locks, a read committed transaction proceeds with its intended update. A serializable transaction, however, fails with the error "Cannot serialize access", because the other transaction has committed a change that was made since the serializable transaction began.

read committed和seriaizabe可以在ORACE并行服务器中使用。

关于SET TRANSACTION READ WRITE：read write和read committed 应该是一样的。在读方面，它们都避免了脏读，但都无法实现重复读。虽然没有文档说明read write在写方面与read committed一致，但显然它在写的时候会加排他锁以避免更新丢失。在加锁的过程中，如果遇到待锁定资源无法锁定，应该是等待而不是放弃。这与 read committed一致。

语句级的读一致性

• ORACE保证语句级的读一致性，即一个语句所处理的数据集是在单一时间点上的数据集，这个时间点是这个语句开始的时间。
• 一个语句看不见在它开始执行后提交的修改。
• 对于DM语句，它看不见由自己所做的修改，即DM语句看见的是它本身开始执行以前存在的数据。

事务级的读一致性

• 事务级的读一致性保证了可重复读，并保证不会出现幻像。

设置隔离级别

设置一个事务的隔离级别

• SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
• SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
• SET TRANSACTION READ ONLY;

设置增个会话的隔离级别

• ATER SESSION SET ISOLATION_LEVE SERIALIZABLE;
• ATER SESSION SET ISOLATION_LEVE READ COMMITTED;

Choice of Isolation Level

Application designers and developers should choose an isolation level based on application performance and consistency needs as well as application coding requirements.

For environments with many concurrent users rapidly submitting transactions, designers must assess transaction performance requirements in terms of the expected transaction arrival rate and response time demands. Frequently, for high-performance environments, the choice of isolation levels involves a trade-off between consistency and concurrency.

Read Committed Isolation

For many applications, read committed is the most appropriate isolation level. Read committed isolation can provide considerably more concurrency with a somewhat increased risk of inconsistent results due to phantoms and non-repeatable reads for some transactions.

Many high-performance environments with high transaction arrival rates require more throughput and faster response times than can be achieved with serializable isolation. Other environments that supports users with a very low transaction arrival rate also face very low risk of incorrect results due to phantoms and nonrepeatable reads. Read committed isolation is suitable for both of these environments.

两种情况：（1）在事务量大、高性能的计算环境，需要更高的吞吐量和响应时间；（2）事务数少，并且发生幻影和不可重复读的几率的比较低

Oracle read committed isolation provides transaction set consistency for every query. That is, every query sees data in a consistent state. Therefore, read committed isolation will suffice for many applications that might require a higher degree of isolation if run on other database management systems that do not use multiversion concurrency control.

Read committed isolation mode does not require application logic to trap the "Cannot serialize access" error and loop back to restart a transaction. In most applications, few transactions have a functional need to issue the same query twice, so for many applications protection against phantoms and non-repeatable reads is not important. Therefore many developers choose read committed to avoid the need to write such error checking and retry code in each transaction.

Serializable Isolation

Oracle's serializable isolation is suitable for environments where there is a relatively low chance that two concurrent transactions will modify the same rows and the long-running transactions are primarily read-only. It is most suitable for environments with large databases and short transactions that update only a few rows.

（1）适合于很少存在两个事务同时修改同一条记录的情况

（2）长事务以只读为主

（3）大型数据库并且每个短事务只修改很少的记录

Serializable isolation mode provides somewhat more consistency by protecting against phantoms and nonrepeatable reads and can be important where a read/write transaction executes a query more than once.

Unlike other implementations of serializable isolation, which lock blocks for read as well as write, Oracle provides nonblocking queries and the fine granularity of row-level locking, both of which reduce write/write contention. For applications that experience mostly read/write contention, Oracle serializable isolation can provide significantly more throughput than other systems. Therefore, some applications might be suitable for serializable isolation on Oracle but not on other systems.

All queries in an Oracle serializable transaction see the database as of a single point in time, so this isolation level is suitable where multiple consistent queries must be issued in a read/write transaction. A report-writing application that generates summary data and stores it in the database might use serializable mode because it provides the consistency that a READ ONLY transaction provides, but also allows INSERT, UPDATE, and DELETE.

（2）rownum对于大于某值的查询条件
   如果想找到从第二行记录以后的记录，当使用rownum>2是查不出记录的，原因是由于rownum是一个总是从1开始的伪列，Oracle 认为rownum> n(n>1的自然数)这种条件依旧不成立，所以查不到记录
SQL> select rownum,id,name from student where rownum >2;
ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
那如何才能找到第二行以后的记录呀。可以使用以下的子查询方法来解决。注意子查询中的rownum必须要有别名，否则还是不会查出记录来，这是因为rownum不是某个表的列，如果不起别名的话，无法知道rownum是子查询的列还是主查询的列。
SQL>select * from(select rownum no ,id,name from student) where no>2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         4 200004 赵四
SQL> select * from(select rownum,id,name from student)where rownum>2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------

（3）rownum对于小于某值的查询条件
如果想找到第三条记录以前的记录，当使用rownum<3是能得到两条记录的。显然rownum对于rownum<n（(n>1的自然数）的条件认为是成立的，所以可以找到记录。
SQL> select rownum,id,name from student where rownum <3;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
        1 200001 张一
        2 200002 王二
综上几种情况，可能有时候需要查询rownum在某区间的数据，那怎么办呀从上可以看出rownum对小于某值的查询条件是人为true的，rownum对于大于某值的查询条件直接认为是false的，但是可以间接的让它转为认为是true的。那就必须使用子查询。例如要查询rownum在第二行到第三行之间的数据，包括第二行和第三行数据，那么我们只能写以下语句，先让它返回小于等于三的记录行，然后在主查询中判断新的rownum的别名列大于等于二的记录行。但是这样的操作会在大数据集中影响速度。
SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         2 200002 王二
         3 200003 李三

（4）rownum和排序
Oracle中的rownum的是在取数据的时候产生的序号，所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出，rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号，rowid也是顺序分配的。为了解决这个问题，必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
这样就成了按name排序，并且用rownum标出正确序号（有小到大）
笔者在工作中有一上百万条记录的表，在jsp页面中需对该表进行分页显示， 便考虑用rownum来作，下面是具体方法(每页
显示20条)：
“select * from tabname where rownum<20 order by name" 但却发现oracle却不能按自己的意愿来执行，而是先随便
取20条记录，然后再 order by，后经咨询oracle,说rownum确实就这样，想用的话，只能用子查询 来实现先排序，后
rownum，方法如下：
"select * from (select * from tabname order by name) where rownum<20",但这样一来，效率会较低很多。
后经笔者试验，只需在order by 的字段上加主键或索引即可让oracle先按 该字段排序，然后再rownum；方法不变：
   “select * from tabname where rownum<20 order by name"

取得某列中第N大的行

select column_name from
(select table_name.*,dense_rank() over (order by column desc) rank from table_name)
where rank = &N；
　假如要返回前5条记录：

　　select * from tablename where rownum<6;(或是rownum <= 5 或是rownum != 6)
假如要返回第5-9条记录：

select * from tablename
where …
and rownum<10
minus
select * from tablename
where …
and rownum<5
order by name
选出结果后用name排序显示结果。(先选再排序)

注意：只能用以上符号(<、<=、!=)。

select * from tablename where rownum != 10;返回的是前９条记录。
不能用：>,>=,=,Between...and。由于rownum是一个总是从1开始的伪列，Oracle 认为这种条件 不成立，查不到记录.

另外，这个方法更快：

select * from (
select rownum r,a from yourtable
where rownum <= 20
order by name )
where r > 10
这样取出第11-20条记录!(先选再排序再选)

要先排序再选则须用select嵌套：内层排序外层选。
rownum是随着结果集生成的，一旦生成，就不会变化了；同时,生成的结果是依次递加的，没有1就永远不会有2!
rownum 是在 查询集合产生的过程中产生的伪列，并且如果where条件中存在 rownum 条件的话，则:

1： 假如 判定条件是常量，则：
只能 rownum = 1, <= 大于1 的自然数， = 大于1 的数是没有结果的， 大于一个数也是没有结果的
即 当出现一个 rownum 不满足条件的时候则 查询结束 　　this is stop key!

2: 当判定值不是常量的时候
若条件是 = var , 则只有当 var 为1 的时候才满足条件，这个时候不存在 stop key ,必须进行 full scan ,对每个满足其他where条件的数据进行判定
选出一行后才能去选rownum=2的行……

   （1）回滚/日志。DELETE语句执行删除的过程是每次从表中删除一行，并且同时将该行的的删除操作作为事务记录在日志中保存以便进行进行回滚操作。TRUNCATE TABLE 则一次性地从表中删除所有的数据页并不把单独的删除操作记录记入日志保存，删除行是不能恢复的。并且在删除的过程中不会激活与表有关的删除触发器。执行速度快。

   （2）表和索引所占空间。当表被TRUNCATE 后，这个表和索引所占用的空间会恢复到初始大小，而DELETE操作不会减少表或索引所占用的空间。

   （3）应用范围。TRUNCATE 只能对TABLE；DELETE可以是table,view,synonym

   （4）TRUNCATE 和DELETE只删除数据，而DROP则删除整个表（结构和数据）。

   （5）TRUNCATE 是DDL；DELETE是DML。

 
truncate、delete（不带where子句）与drop的异同点：
相同之处：
    三者均会删除表内的data。
不同点：
   <1>、truncate与不带where的delete ：只删除数据，而不删除表的结构（定义）
        drop语句将删除表的结构被依赖的约束（constrain),触发器（trigger), 索引（index);依赖于该表的存储过程/函数将被保留，但其状态会变为：invalid。
   <2>、delete语句为DML（data maintain Language),这个操作会被放到 rollback segment中,事务提交后才生效。如果有相应的 tigger,执行的时候将被触发。
       truncate、drop是DLL（data define language),操作立即生效，原数据不放到 rollback segment中，不能回滚；操作不触发 trigger。
   <3>、delete语句不影响表所占用的 extent（段）,高水线（high watermark)保持原位置不动。
         drop语句将表所占用的空间全释放掉。
         truncate语句缺省情况下将空间释放到 minextents 个 extent,除非使用 renuse storage;truncate 会将高水线(high watermark)复位（回到最初位置）。
   <4>、速度：
      一般而言，drop > truncate > delete。
   <5>、安全性：
       在没有备份情况下，谨慎使用 drop 与 truncate。要删除部分数据行采用 delete且注意结合where来约束影响范围。回滚段要足够大。要删除表用drop;若想保留表而将表中数据删除，如果于事务无关，用truncate即可实现。如果和事务有关，或老师想触发trigger,还是用delete。
      如果是整理表内部的碎片，可以用truncate并结合reuse storage,再重新导入/插入数据。
附Microsoft SQL
Truncate是SQL中的一个删除数据表内容的语句，用法是：
TRUNCATE TABLE [Table Name]。
下面是对Truncate语句在MSSQLServer2000中用法和原理的说明：
Truncate table 表名 速度快,而且效率高,因为:
truncate table 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。
DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。
TRUNCATE TABLE 删除表中的所有行，但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。如果想保留标识计数值，请改用 DELETE。如果要删除表定义及其数据，请使用 DROP TABLE 语句。
对于由 FOREIGN KEY 约束引用的表，不能使用 TRUNCATE TABLE，而应使用不带 WHERE 子句的 DELETE 语句。由于 TRUNCATE TABLE 不记录在日志中，所以它不能激活触发器。
TRUNCATE TABLE 不能用于参与了索引视图的表

//主键549830479

   alter table tabelname add new_field_id int(5) unsigned default 0 not null auto_increment ,add primary key (new_field_id);
//增加一个新列549830479

   alter table t2 add d timestamp;
alter table infos add ex tinyint not null default '0';
//删除列549830479

   alter table t2 drop column c;
//重命名列549830479

   alter table t1 change a b integer;

//改变列的类型549830479

   alter table t1 change b b bigint not null;
alter table infos change list list tinyint not null default '0';

//重命名表549830479

   alter table t1 rename t2;
加索引549830479

   mysql> alter table tablename change depno depno int(5) not null;
mysql> alter table tablename add index 索引名 (字段名1[，字段名2 …]);
mysql> alter table tablename add index emp_name (name);
加主关键字的索引549830479

mysql> alter table tablename add primary key(id);
加唯一限制条件的索引549830479

  mysql> alter table tablename add unique emp_name2(cardnumber);
删除某个索引549830479

   mysql>alter table tablename drop index emp_name;
修改表：549830479

增加字段：549830479

   mysql> ALTER TABLE table_name ADD field_name field_type;
修改原字段名称及类型：549830479

   mysql> ALTER TABLE table_name CHANGE old_field_name new_field_name field_type;
删除字段：549830479

   mysql> ALTER TABLE table_name DROP field_name;

mysql 常用增删改查命定
关键字: mysql增删改查
插入一条记录:
          mysql> insert into table_name (column_name1,column_name2,.) values (value1,value2,..);
更新一条记录：
          mysql> update tbl_name
set col_name1=expr1 [, col_name2=expr2 ...][WHERE where_definition]
[ORDER BY ...][LIMIT row_count];
删除一条记录：
         mysql>delete from table_name where id=XX;
删除整个表的数据：
         mysql> drop from table_name;
查询一条记录：
         mysql>select * from table_name where id=XX;

mysql中删除部分重复记录的方法
关键字: mysql中删除部分重复记录
假设person表中有三个字段 分别是id(自增) name age 部分记录中的name ,age出现重复
比如
id             name              age
1           zhangsan            20
2           zhangsan            20
3               lisi                    25
4               lisi                    25
1 ,2 部分重复，3,4也是部分重复 ，现在四条记录我只保留不重复的两条。删除方法如下：

1.按name,age分组查询出所有不重复的id并放入到tmp表中
  create table tmp select min(id) as id from person group by name,age;

2.根据上面查询出的id号从person表中查询出所有的数据并放到表tmp2中
  create table tmp2 select person.* from person,tmp where person.id = tmp.id;

3.删除person表
  drop table person;

4.把tmp2重命名为person
  rename table tmp2 to person;

需求要求实现用弹出层发送邮件。提交后层关闭，程序再服务器端响应。

JSON插件提供了一种名为json的ResultType，一旦为某个Action指定了一个类型为json的Result，则该Result无需映射到任何视图资源。因为JSON插件会负责将Action里的状态信息序列化成JSON格式的数据，并将该数据返回给客户端页面的JavaScript 。

简单地说，JSON插件允许我们在JavaScript中异步调用Action，而且Action不再需要使用视图资源来显示该Action里的状态信息，而是由JSON插件负责将Action里的状态信息返回给调用页面——通过这种方式，就可以完成Ajax交互。

1、将struts2的json插件加入web工程的lib，jsonplugin的下载地址：http://code.google.com/p/jsonplugin/downloads/list

2、struts.xml添加专为ajax使用的package 

 <package name="ajax" extends="json-default">
        <action name="ajaxRequest"  class="org.david.struts2.HelloWorld">
            <result type="json"></result>
        </action>
</package>        
             
3、在页面中引入 jquery的js文件库       

    <SCRIPT type="text/javascript" src="js/jquery-1.2.6.min.js"></script>
 <SCRIPT type="text/javascript">
            function clickButton()
            {    
                var url = 'ajaxRequest.action';
                var params = {
                        name:$('#name').attr('value'),
                           contactEmail:$('#contactEmail').attr('value'),
                           subject:$('#subject').attr('value'),
                           content:$('#content').attr('value')                

                       }; //通过id获得输入值
                 jQuery.post(url, params, callbackFun, 'json');

               } //url：响应aciton；params：传入参数；callbackFun：响应完成后的回调函数；
            

               function callbackFun(data)
            {
                 alert("SUCCESS");
                }
     </SCRIPT>

4、action逻辑与普通的ation写法无大区别。

     JSON将Action里的状态信息序列化成JSON格式的数据