配置一个数据源
    Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。

 DBCP数据源
    DBCP类包位于 <spring_home></spring_home>/lib/jakarta-commons/commons-dbcp.jar，DBCP是一个依赖 Jakarta commons-pool对象池机制的数据库连接池，所以在类路径下还必须包括<spring_home></spring_home>/lib/jakarta- commons/commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：

oracle xe universal默认创建AL32UTF8字符集,这种字符集1个汉字占用3个字节，而
ZHS16GBK字符集1个汉字占用2个字节，为了节约空间，我尝试改变数据库的字符集，
但是失败了，因为新字符集不是旧字符集的超集。即使用restrict模式也不行。
考虑到oracle xe 安装时只是建一个空库，仅包含系统表空间等，设想通过手工执行
创建ZHS16GBK字符集数据库的办法实现。
从sybex的10g ocp教材中复制并修改得下面语句，其中E:\ORADATA\TEST是我们要存放
新数据库物理文件的目录，以和旧数据库区分。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/l1t/archive/2006/05/31/765125.aspx

        数据字典dict总是属于Oracle用户sys的。
　　1、用户：
　　　select username from dba_users;
　　改口令
　　　alter user spgroup identified by spgtest;
　　2、表空间：
　　　select * from dba_data_files;
　　　select * from dba_tablespaces;//表空间

　　　select tablespace_name,sum(bytes), sum(blocks)
　　　　from dba_free_space group by tablespace_name;//空闲表空间

　　　select * from dba_data_files
　　　　where tablespace_name='RBS';//表空间对应的数据文件

　　　select * from dba_segments
　　　　where tablespace_name='INDEXS';
　　3、数据库对象：
　　　select * from dba_objects;
　　　CLUSTER、DATABASE LINK、FUNCTION、INDEX、LIBRARY、PACKAGE、PACKAGE BODY、
　　　PROCEDURE、SEQUENCE、SYNONYM、TABLE、TRIGGER、TYPE、UNDEFINED、VIEW。
　　4、表：
　　　select * from dba_tables;
　　　analyze my_table compute statistics;->dba_tables后6列
　　　select extent_id,bytes from dba_extents
　　　where segment_name='CUSTOMERS' and segment_type='TABLE'
　　　order by extent_id;//表使用的extent的信息。segment_type='ROLLBACK'查看回滚段的空间分配信息
　　　列信息：
　　　　select distinct table_name
　　　　from user_tab_columns
　　　　where column_name='SO_TYPE_ID';
　　5、索引：　
　　　select * from dba_indexes;//索引，包括主键索引
　　　select * from dba_ind_columns;//索引列
　　　select i.index_name,i.uniqueness,c.column_name
　　　　from user_indexes i,user_ind_columns c
　　　　　where i.index_name=c.index_name
　　　　　and i.table_name ='ACC_NBR';//联接使用
　　6、序列：
　　　select * from dba_sequences;
　　7、视图：
　　　select * from dba_views;
　　　select * from all_views;
　　text 可用于查询视图生成的脚本
　　8、聚簇：
　　　select * from dba_clusters;
　　9、快照：
　　　select * from dba_snapshots;
　　快照、分区应存在相应的表空间。
　　10、同义词：
　　　select * from dba_synonyms
　　　　where table_owner='SPGROUP';
　　　　//if owner is PUBLIC,then the synonyms is a public synonym.
　　　　　if owner is one of users,then the synonyms is a private synonym.
　　11、数据库链：
　　　select * from dba_db_links;
　　在spbase下建数据库链
　　　create database link dbl_spnew
　　　connect to spnew identified by spnew using 'jhhx';
　　　insert into acc_nbr@dbl_spnew
　　　select * from acc_nbr where nxx_nbr='237' and line_nbr='8888';
　　12、触发器：
　　　select * from dba_trigers;
　　存储过程，函数从dba_objects查找。
　　其文本：select text from user_source where name='BOOK_SP_EXAMPLE';
　　建立出错：select * from user_errors;
　　oracle总是将存储过程，函数等软件放在SYSTEM表空间。
　　13、约束：
　　（1）约束是和表关联的，可在create table或alter table table_name add/drop/modify来建立、修改、删除约束。
　　可以临时禁止约束，如：
　　　alter table book_example
　　　disable constraint book_example_1;
　　　alter table book_example
　　　enable constraint book_example_1;
　　（2）主键和外键被称为表约束，而not null和unique之类的约束被称为列约束。通常将主键和外键作为单独的命名约束放在字段列表下面，而列约束可放在列定义的同一行，这样更具有可读性。
　　（3）列约束可从表定义看出，即describe;表约束即主键和外键，可从dba_constraints和dba_cons_columns 查。
　　　select * from user_constraints
　　　where table_name='BOOK_EXAMPLE';
　　　select owner,CONSTRAINT_NAME,TABLE_NAME
　　　　from user_constraints
　　　　where constraint_type='R'
　　　　order by table_name;
　　（4）定义约束可以无名（系统自动生成约束名）和自己定义约束名（特别是主键、外键）
　　如：create table book_example
　　　　(identifier number not null);
　　　　create table book_example
　　　　(identifier number constranit book_example_1 not null);
　　14、回滚段：
　　在所有的修改结果存入磁盘前，回滚段中保持恢复该事务所需的全部信息，必须以数据库发生的事务来相应确定其大小（DML语句才可回滚，create,drop,truncate等DDL不能回滚）。
　　回滚段数量=并发事务/4，但不能超过50；使每个回滚段大小足够处理一个完整的事务；
　　　create rollback segment r05
　　　tablespace rbs;
　　　create rollback segment rbs_cvt
　　　tablespace rbs
　　　storage(initial 1M next 500k);
　　使回滚段在线
　　　alter rollback segment r04 online;
　　用dba_extents,v$rollback_segs监测回滚段的大小和动态增长。
　　回滚段的区间信息
　　　select * from dba_extents
　　　where segment_type='ROLLBACK' and segment_name='RB1';
　　回滚段的段信息,其中bytes显示目前回滚段的字节数
　　　select * from dba_segments
　　　　where segment_type='ROLLBACK' and segment_name='RB1';
　　为事物指定回归段
　　　set transaction use rollback segment rbs_cvt
　　针对bytes可以使用回滚段回缩。
　　　alter rollback segment rbs_cvt shrink;
　　　select bytes,extents,max_extents from dba_segments
　　　　where segment_type='ROLLBACK' and segment_name='RBS_CVT';
　　回滚段的当前状态信息：
　　　select * from dba_rollback_segs
　　　　where segment_name='RB1';
　　比多回滚段状态status，回滚段所属实例instance_num
　　查优化值optimal
　　　select n.name,s.optsize
　　　　from v$rollname n,v$rollstat s
　　　　　where n.usn=s.usn;
　　回滚段中的数据
　　　set transaction use rollback segment rb1;/*回滚段名*/
　　　select n.name,s.writes
　　　　from v$rollname n,v$rollstat s
　　　　　where n.usn=s.usn;
　　当事务处理完毕，再次查询$rollstat，比较writes(回滚段条目字节数)差值，可确定事务的大小。
　　查询回滚段中的事务
　　　column rr heading 'RB Segment' format a18
　　　column us heading 'Username' format a15
　　　column os heading 'Os User' format a10
　　　column te heading 'Terminal' format a10
　　　select r.name rr,nvl(s.username,'no transaction') us,s.osuser os,s.terminal te
　　　　from v$lock l,v$session s,v$rollname r
　　　　　where l.sid=s.sid(+)
　　　　　and trunc(l.id1/65536)=R.USN
　　　　　and l.type='TX'
　　　　　and l.lmode=6
　　　order by r.name;
　　15、作业
　　查询作业信息
　　　select job,broken,next_date,interval,what from user_jobs;
　　　select job,broken,next_date,interval,what from dba_jobs;
　　查询正在运行的作业
　　　select * from dba_jobs_running;
　　使用包exec dbms_job.submit(:v_num,'a;',sysdate,'sysdate + (10/(24*60*60))')加入作业。间隔10秒钟
exec dbms_job.submit(:v_num,'a;',sysdate,'sysdate + (11/(24*60))')加入作业。间隔11分钟使用包exec dbms_job.remove(21)删除21号作业。

    第一种方式：每个Bean都有一个代理

<bean id="sessionFactory"               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">           <property name="configLocation" value="classpath:hibernate.cfg.xml" />           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />     </bean>        <!-- 定义事务管理器（声明式的事务） -->       <bean id="transactionManager"         class="org.springframework.orm.hibernate3.HibernateTransactionManager">         <property name="sessionFactory" ref="sessionFactory" />     </bean>          <!-- 配置DAO -->     <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">         <property name="sessionFactory" ref="sessionFactory" />     </bean>          <bean id="userDao"           class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">              <!-- 配置事务管理器 -->              <property name="transactionManager" ref="transactionManager" />              <property name="target" ref="userDaoTarget" />            <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />         <!-- 配置事务属性 -->           <property name="transactionAttributes">               <props>                   <prop key="*">PROPAGATION_REQUIRED</prop>             </props>           </property>       </bean>   </beans>

第二种方式：所有Bean共享一个代理基类

第三种方式：使用拦截器

<bean id="sessionFactory"               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">           <property name="configLocation" value="classpath:hibernate.cfg.xml" />           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />     </bean>        <!-- 定义事务管理器（声明式的事务） -->       <bean id="transactionManager"         class="org.springframework.orm.hibernate3.HibernateTransactionManager">         <property name="sessionFactory" ref="sessionFactory" />     </bean>          <bean id="transactionInterceptor"           class="org.springframework.transaction.interceptor.TransactionInterceptor">           <property name="transactionManager" ref="transactionManager" />           <!-- 配置事务属性 -->           <property name="transactionAttributes">               <props>                   <prop key="*">PROPAGATION_REQUIRED</prop>               </props>           </property>       </bean>            <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">           <property name="beanNames">               <list>                   <value>*Dao</value>             </list>           </property>           <property name="interceptorNames">               <list>                   <value>transactionInterceptor</value>               </list>           </property>       </bean>          <!-- 配置DAO -->     <bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">         <property name="sessionFactory" ref="sessionFactory" />     </bean> </beans>

第四种方式：使用tx标签配置的拦截器

<context:annotation-config />     <context:component-scan base-package="com.bluesky" />      <bean id="sessionFactory"               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">           <property name="configLocation" value="classpath:hibernate.cfg.xml" />           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />     </bean>        <!-- 定义事务管理器（声明式的事务） -->       <bean id="transactionManager"         class="org.springframework.orm.hibernate3.HibernateTransactionManager">         <property name="sessionFactory" ref="sessionFactory" />     </bean>      <tx:advice id="txAdvice" transaction-manager="transactionManager">         <tx:attributes>             <tx:method name="*" propagation="REQUIRED" />         </tx:attributes>     </tx:advice>          <aop:config>         <aop:pointcut id="interceptorPointCuts"             expression="execution(* com.bluesky.spring.dao.*.*(..))" />         <aop:advisor advice-ref="txAdvice"             pointcut-ref="interceptorPointCuts" />             </aop:config>       </beans>

第五种方式：全注解

<context:annotation-config />     <context:component-scan base-package="com.bluesky" />      <tx:annotation-driven transaction-manager="transactionManager"/>      <bean id="sessionFactory"               class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">           <property name="configLocation" value="classpath:hibernate.cfg.xml" />           <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />     </bean>        <!-- 定义事务管理器（声明式的事务） -->       <bean id="transactionManager"         class="org.springframework.orm.hibernate3.HibernateTransactionManager">         <property name="sessionFactory" ref="sessionFactory" />     </bean>      </beans>

此时在DAO上需加上@Transactional注解，如下：

1. package com.bluesky.spring.dao;  
2.   
3. import java.util.List;  
4.   
5. import org.hibernate.SessionFactory;  
6. import org.springframework.beans.factory.annotation.Autowired;  
7. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
8. import org.springframework.stereotype.Component;  
9.   
10. import com.bluesky.spring.domain.User;  
11.   
12. @Transactional  
13. @Component("userDao")  
14. public class UserDaoImpl extends HibernateDaoSupport implements UserDao {  
15.   
16.     public List<User> listUsers() {  
17.         return this.getSession().createQuery("from User").list();  
18.      }  
19.       
20.       
21. } 

在文件 tnsnames.ora 下增加GFS =
  (DESCRIPTION =
    (ADDRESS_LIST =
      (ADDRESS = (PROTOCOL = TCP)(HOST = 10.2.4.95)(PORT = 1521))
    )
    (CONNECT_DATA =
      (SERVICE_NAME = pay)
    )
  )

此文件在%oracle_home%\product\10.1.0\Db_1\NETWORK\ADMIN

服务启动的是后台进程，这类似 于Unix中的守护进程。当Oracle数据库服务启动时，系统中没有典型的Oracle进程运行。相反，该服务进程等待来自SQL*Plus的最初连 接，这引起一个前台进程启动并创建该系统全局区域SGA的后台进程。当Oracle数据库关闭时，所有创建的进程被终止。但是该进程自身仍在继续运行，等 待下一个连接请求和启动命令。这就是当我们通过Windows中的Oracle Service启动了数据库实 例，但在SQL*Plus或Oracle企业管理器中关闭了数据库实例后，然而Windows中的OracleService服务仍处于“已启动”状态的 原因。只有停止Windows中的Oracle Service服务（即进程），才能保证不启动数据库。当然，当OracleService服务停止后，还可通过其他方式启动数据库实例。有多种方式可实 现对Windows中有关Oracle服务的管理，具体内容可详见后面相关章节。

Oracle 网络监听器（Net Listener）是另一个重要的服务。该服务必须在用户能连接到Oracle数据库之前启动运行。该进程关闭与否并不影响已经在客户端与数据库之间建立 起的连接和用户对数据库的使用。以SQL*Plus为例，当Oracle网络监听器的服务OracleTNSListener启动之前，启动 SQL*Plus并连接至数据库，系统出现错误信息“ORA-12541:TNS:nolistener”。原因是没有启动监听服务或者监听器损坏；当 Oracle网络监听器的服务启动SQL*Plus并连接至数据库后，若停止OracleTNSListener服务，则对SQL*Plus没有任何影 响，只要没有断开连接，SQL*Plus仍可与数据库进行数据交互。其中，TNS（Transparent Network Substrate）代表透明网络层。

2.可用的Oracle服务

根据安装的产品不同，在Windows中产生的Oracle服务也不同，其实也正是这一点说明了数据库服务器与其所使用的操作系统是紧密相关的。

Oracle Database 10g安装后生成多个服务，这些都是Oracle Database 10g运行中所必需的。

通常当创建数据库并完成安装后，以下两个主要服务会自动启动：

·Oracle Service (Oracle数据库服务)

·OracleTNSListener (Oracle数据库监听服务)

如果安装了Oracle Enterprise Manager Database

Control，则OracleDBConsole服务自动启动。若配置了Automatic Storage

Management,则OracleCSService和OracleASMService+ASM服务也会出现在服务列表中。

与Oracle 10g不同，Oracle9i安装完成后产生12个与其有关的服务，为便于比较，下面是几个与Oracle9i数据库相关的服务：

(1)Oracle Service

数据库服务。该服务为数据库实例系统标识符SID而创建，SID是Oracle安装期间输入的数据库服务名字(如OracleServiceTEST)。该服务是强制性的，它担负着启动数据库实例的任务。

如果没有启动该服务，则当使用任何Oracle工具如SQL*Plus时，将出现ORA-12560的错误信息提示。该信息内容是“ORA-12560 TNS:

protocol adapter error”，这也意味着数据库管理系统的管理对象没有启动，即数据库没有工作。当系统中安装了多个数据库时，会有多个Oracle Service，SID会因数据库不同而不同。一般将服务的启动类型设置为“自动”，这样，当计算机系统启动后该服务自动启动。

（2）OracleTNSListener

监听器服务。例如，Oracle

OraHome92TNSListener 承担着监听并接受来自客户端应用程序的连接请求的任务。当Windows计算机重新启动后，该服务将自动启动。如果该服务没有启动，那么当你使用 Oracle企业管理器控制台或一些图形化的工具进行连接时，将出现错误信息“ORA-12541 TNS: no listener”。但对一般的连接并无影响。例如，在MS-DOS提示符中用sqlplus/ @net_service_name形式启动SQL*Plus并进行连接时，则不会出现错误信息提示。一般将该服务的启动类型设置为“自动”，这样，当计 算机系统启动后该服务自动启动。也可通过手动方式启动服务：C:\>net start OracleTNSListener。

注意 在连接上出现的问题，多数都与监听器有关。

（3）OracleAgent

代理服务。该服务是Oracle企业管理器产品的一部分。执行作业和监视Oracle服务性能及监听器、数据库、Oracle HTTP

Server和Oracle应用程序等目标需要使用智能代理（Intelligent Agent）。智能代理还为Capacity

Planner和Performance Manager等收集静态数据。Capacity Planner和Performance

Manager是用于Oracle诊断包的数据收集应用程序。一般将该服务的启动类型设置为“自动”，这样，当计算机系统启动后该服务自动启动。

如 果该代理服务没有启动，则在启动OEM Console时，系统无法通过OracleAgent找到数据库所在的节点。因此，在使用Enterprise Manager Console打开控制台时，因无法找到数据库所在的节点而不能显示该数据库。OracleAgent是否启动也影响着数据库的远程连接。

在网络中，Oracle Intelligent

Agent是一个在远程节点上的自治进程。代理作为服务与Oracle数据库服务器驻留在同一个节点上，并提供和完成下列功能：

·提供本地服务或调用依赖于操作系统的服务，以便与本地管理的目标节点交互。

·检查事件，向OEM报告排队的结果事件。

·运行Oracle Enterprise Manager作业，搜集其结果和输出，并为结果排队。

·处理数据集合。

·取消那些由控制台或其他应用程序控制的作业或事件等。

（4）OracleHTTPServer

该服务使用端口号3339，为基于浏览器的企业管理器及资料档案库启动Oracle HTTP Server。它对应于Apache Server，即Web

Server。 它也是运行iSQL*Plus所必需的中间层。可根据实际情况将该服务的启动类型设置为“自动”或“手动”。当设置为“自动”后，Oracle HTTPServer将随着计算机的启动而自动启动；否则，可通过菜单组中的“Start HTTP Server powered by Apache”来启动Oracle HTTP Server。

（5）OracleManagementServer OMS(Oracle Management Server)服务在客户端与所管理目标之间起着集中管理和分布式的控制作用，与代理协同工作，处理监视信息和作业信息并使用管理资料档案库存储其管理数据。

1.修改C:\jboss-4.0.5.GA\server\default\deploy\jbossweb-tomcat55.sar\server.xml
在</host>前面加上<Context path="/gfs"  docBase="D:/workspace/GFS/WebContent" reloadable="true"/>

 2.删除工程的web-inf/lib下和jboss冲突的包，只要重新更新一下svn就ok
 3.更新src目录，增加了com/alipay/gfs/resource包,下面放了spring和ibatis的xml和消息文件
 4.删除web-inf目录需按的3中的xml文件，只要更新svn
 5.修改web.xml 只要更新svn
 6.去掉eclipse启动jboss的时候自动部署
 以后，修改jsp，java或者xml文件都必须要重新部署

1. 基本语法
　　CSS的定义是由三个部分构成：选择符（selector），属性（properties）和属性的取值（value）。
　　基本格式如下：

selector {property: value} 
（选择符 {属性：值}）

资料引用:http://www.knowsky.com/441346.html

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

 <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
  <property name="host">
   <value>smtp.163.com</value>
  </property>
  <property name="username">
   <value>lihaijun_ssd@163.com</value>
  </property>
  <property name="password">
   <value>******</value>
  </property>
  <property name="javaMailProperties">
   <props>
    <prop key="mail.smtp.auth">true</prop>
    <prop key="mail.smtp.timeout">25000</prop>
   </props>
  </property>
 </bean>

 <bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
  <property name="from">
   <value>lihaijun_ssd@163.com</value>
  </property>
  <property name="to">
   <value>lihaijun_ssd@163.com</value>
  </property>
  <property name="subject">
   <value>标题</value>
  </property>
  <property name="text">
   <value>内容</value>
  </property>
 </bean>

 <bean id="orderManager" class="OrderManagerImp">
  <property name="mailsender">
   <ref bean="mailSender" />
  </property>
  <property name="message">
   <ref bean="mailMessage" />
  </property>
 </bean>
</beans>

3.OrderManagerImpl代码如下：
import org.springframework.mail.MailException;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;

public class OrderManagerImpl{
 private JavaMailSender mailsender;
 private SimpleMailMessage message;

 public void setMessage(SimpleMailMessage message) {
  this.message = message;
 }

 public void setMailsender(JavaMailSender mailsender) {
  this.mailsender = mailsender;
 }

 public void placeOrder() {
  try {
   mailsender.send(message);
  } catch (MailException ex) {
   System.err.println(ex.getMessage());
  }
 }
}

4.SpringMailTest文件代码如下：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMailTest {

 public static void main(String[] args) {
  ApplicationContext bf = new ClassPathXmlApplicationContext("applicationContext.xml");
  OrderManager mail = (OrderManager) bf.getBean("orderManager");
  mail.placeOrder();
 }
}

5.最后要把杀毒软件和防火墙关掉才能正常发送邮件（我的机子要把McAfee的“访问保护”关掉）

在OO设计领域，我们知道前人总结了不少的经验，许多的经验在现代软件工程过程中已经被认为是原则来遵守。下面笔者摘抄几项下文涉及到的OO原则的定义。

OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。我的理解是，对于一个已有的软件，如果需要扩展，应当在不需修改已有代码的基础上进行。

DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。我的理解是，对于不同层次的编程，高层次暴露给低层次的应当只是接口，而不是它的具体类。

LoD （迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。众所周知类（或模块）之间的通信越少，耦合度就越低，从而更有利于我们对软件的宏观管理。 老子论“圣人之治”有相同的思想，《老子》云：“是以圣人之治，虚其心，实其腹，弱其志，常使民无知无欲。”，又云：“小国寡民，邻国相望，鸡犬之声相 闻，民至老死，不相往来。”。佩服我们的老祖宗，N千年前就想到了西方N千年后才想到的东西，同时也佩服《java与模式》的作者阎宏，可以用中国传统哲 学思想这么生动的说明这一软件设计原则。

简单工厂模式及实例

简单工厂模式又叫静态工厂模式，顾名思义，它是用来实例化目标类的静态类。下面我主要通过一个简单的实例说明简单工厂及其优点。

比 如有个国家的运动员协会，他们是负责登记与注册职业运动员的（就好像我们国家的体育总局，呵呵，无论足球篮球还是乒乓球的运动员都必须在这里注册才能拿到 我们国家职业运动员牌照）。一家体育俱乐部（比如篮球的广东宏远，足球的深圳健力宝）想获得球员为自己俱乐部效力，就必须通过这个运动员协会。

       根据DIP我们可以设计一个“运动员”接口，“足球运动员”和“篮球运动员”（还有其他运动员）都实现“运动员”这个接口。而“运动员协会”就是一个简单工 厂类，它负责实例化“运动员”。我们这里的“俱乐部”就是一个客户端（Client），不同的“俱乐部”就是不同的客户端。

       对于不同的俱乐部对象（无论是八一还是深圳健力宝），他们都是面向“运动员”接口编程，而不用管是“足球运动员”还是“篮球运动员”，也就是说实现了“运动 员”接口的具体类“足球运动员”无需暴露给客户端。这也满足了DIP。但具体的俱乐部（比如足球的深圳健力宝）如何确保自己获取的是自己想要的运动员（健 力宝俱乐部需要的当然是足球运动员）呢？这就需要“运动员协会”这一工厂类了。俱乐部通过调用“运动员协会”的具体方法，返回不同的实例。这同时也满足了 LoD，也就是“深圳健力宝足球俱乐部”对象不直接与“足球运动员：李毅”对象通信，而是通过他们共同的“朋友”——“国家体育总局”通信。

下面给出各个类的程序，会有助于读者更好的了解笔者之前的介绍。

Code:

[Copy to clipboard]

运动员.java   public interface 运动员 {                   public void 跑();           public void 跳(); } 足球运动员.java public class 足球运动员 implements 运动员 {           public void 跑(){                   //跑啊跑           }                    public void 跳(){                   //跳啊跳           } } 篮球运动员.java public class 篮球运动员 implements 运动员 {           public void 跑(){                   //do nothing           }                    public void 跳(){                   //do nothing           } } 体育协会.java public class 体育协会 {                    public static 运动员 注册足球运动员(){                   return new 足球运动员();           }                    public static 运动员 注册篮球运动员(){                   return new 篮球运动员();           } } 俱乐部.java public class 俱乐部 {           private 运动员 守门员;           private 运动员 后卫;           private 运动员 前锋;           public void test() {                   this.前锋 = 体育协会.注册足球运动员();                   this.后卫 = 体育协会.注册足球运动员();                   this.守门员 = 体育协会.注册足球运动员();                                    守门员.跑();                   后卫.跳();           } }

以上就是简单工厂模式的一个简单实例，读者应该想象不用接口不用工厂而把具体类暴露给客户端的那种混乱情形吧（就好像没了体育总局，各个俱乐部在市场上自己胡乱的寻找仔细需要的运动员），简单工厂就解决了这种混乱。

我 们用OCP看看简单工厂，会发现如果要对系统进行扩展的话治需要增加实现产品接口的产品类（上例表现为“足球运动员”，“篮球运动员”类，比如要增加个 “乒乓球运动员”类），而无需对原有的产品类进行修改。这咋一看好像满足OCP，但是实际上还是需要修改代码的——对，就是修改工厂类。上例中如果增加 “乒乓球运动员”产品类，就必须相应的修改“体育协会”工厂类，增加个“注册乒乓球运动员”方法。所以可以看出，简单工厂模式是不满足OCP的。

工厂方法模式及其实例

谈 了简单工厂模式，下面继续谈谈工厂方法模式。前一节的最末点明了简单工厂模式最大的缺点——不完全满足OCP。为了解决这一缺点，设计师们提出了工厂方法 模式。工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接 口的工厂类。下面我们通过修改上一节的实例来介绍工厂方法模式。

我们在不改变产品类（“足球运动员”类和“篮球运动员”类）的情况下，修改下工厂类的结构，如下图所示：

相关代码如下：

Code:

[Copy to clipboard]

运动员.java   public interface 运动员 {                   public void 跑();           public void 跳(); } 足球运动员.java public class 足球运动员 implements 运动员 {           public void 跑(){                   //跑啊跑           }                    public void 跳(){                   //跳啊跳           } } 篮球运动员.java public class 篮球运动员 implements 运动员 {           public void 跑(){                   //do nothing           }                    public void 跳(){                   //do nothing           } } 体育协会.java public interface 体育协会 {           public 运动员 注册(); } 足球协会.java public class 足球协会 implements 体育协会 {           public 运动员 注册(){                   return new 足球运动员();           } } 篮球协会.java public class 篮球协会 implements 体育协会 {           public 运动员 注册(){                   return new 篮球运动员();           } } 俱乐部.java public class 俱乐部 {           private 运动员 守门员;           private 运动员 后卫;           private 运动员 前锋;           public void test() {                   体育协会 中国足协 = new 足球协会();                                    this.前锋 = 中国足协.注册();                   this.后卫 = 中国足协.注册();                   守门员.跑();                   后卫.跳();           } }

很明显可以看到，“体育协会”工厂类变成了“体育协会”接口，而实现此接口的分别是“足球协会”“篮球协会”等等具体的工厂类。

这样做有什么好处呢？很明显，这样做就完全OCP了。如果需要再加入（或扩展）产品类（比如加多个“乒乓球运动员”）的话就不再需要修改工厂类了，而只需相应的再添加一个实现了工厂接口（“体育协会”接口）的具体工厂类。

从以上对两种模式的介绍可以了解到，工厂方法模式是为了克服简单工厂模式的缺点（主要是为了满足OCP）而设计出来的。但是，工厂方法模式就一定比简单工厂模式好呢？笔者的答案是不一定。下面笔者将详细比较两种模式。

1. 结构复杂度

从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。

2.代码复杂度

代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

3.客户端编程难度

工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

4.管理上的难度

这是个关键的问题。

我 们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性呢？答案是否定的。简单工厂模式同 样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但笔者认为不需要太拘 泥于设计理论，要知道，sun提供的java官方工具包中也有想到多没有满足OCP的例子啊（java.util.Calendar这个抽象类就不满足 OCP，具体原因大家可以分析下）。

然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时 需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改是，简单工厂模式 仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大不了把这个类重写）。

由以上的分析，笔者认为简单工厂模式更好用更方便些。当然这只是笔者的个人看法而已，毕竟公认的，工厂方法模式比简单工厂模式更“先进”。但有时过于先进的东西未必适合自己，这个见仁见智吧。

一、PL/SQL出现的目的

　　结构化查询语言(Structured Query Language，简称SQL)是用来访问关系型数据库一种通用语言，它属于第四代语言（4GL），其执行特点是非过程化，即不用指明执行的具体方法和途径，而是简单的调用相应语句来直接取得结果即可。显然，这种不关注任何实现细节的语言对于开发者来说有着极大的便利。 然而，对于有些复杂的业务流程又要求相应的程序来描述，那么4GL就有些无能为力了。PL/SQL的出现正是为了解决这一问题，PL/SQL是一种过程化语言，属于第三代语言，它与C,C++,Java等语言一样关注于处理细节，因此可以用来实现比较复杂的业务逻辑。

　　本教程分两部分，第一部分主要对PL/SQL的编程基础进行讨论，第二部分结合一个案例来讲解PL/SQL编程。希望读者阅读本文后能够对PL/SQL编程有一个总体上的认识，为今后深入PL/SQL编程打下一个基础。

二、PL/SQL编程基础

　　掌握一门编程语言首要是要了解其基本的语法结构，即程序结构、数据类型、控制结构以及相应的内嵌函数（或编程接口）。

　　1、PL/SQL程序结构

　　PL/SQL程序都是以块（block）为基本单位。如下所示为一段完整的PL/SQL块：

/*声明部分，以declare开头*/
declare
v_id integer;
v_name varchar(20);
cursor c_emp is select * from employee where emp_id=3;
/*执行部分，以begin开头*/
begin
　open c_emp;　　　　　　　　　　　　　--打开游标
　loop
　　fetch c_emp into v_id,v_name;　　--从游标取数据
　　exit when c_emp%notfound ;
　end loop ;
close c_emp;　　　　　　　　　　 --关闭游标
dbms_output.PUT_LINE(v_name);
/*异常处理部分，以exception开始*/
exception
　when no_data_found then
　　dbms_output.PUT_LINE('没有数据');
end ;

　　从上面的PL/SQL程序段看出，整个PL/SQL块分三部分：声明部分（用declare开头）、执行部分（以begin开头）和异常处理部分（以exception开头）。其中执行部分是必须的，其他两个部分可选。无论PL/SQL程序段的代码量有多大，其基本结构就是由这三部分组成。

　　2、变量声明与赋值

　　PL/SQL主要用于数据库编程，所以其所有数据类型跟oracle数据库里的字段类型是一一对应的，大体分为数字型、布尔型、字符型和日期型。为方便理解后面的例程，这里简单介绍两种常用数据类型：number、varchar2。

　　 number

　　用来存储整数和浮点数。范围为１E-130 ～10E125，其使用语法为：

number［（precision, scale）］

　　其中（precision, scale）是可选的，precision表示所有数字的个数，scale表示小数点右边数字的个数。

　　 varchar2

　　用来存储变长的字符串，其使用语法为：

varchar2［（size）］

　　其中size为可选，表示该字符串所能存储的最大长度。

　　在PL/SQL中声明变量与其他语言不太一样，它采用从右往左的方式声明，比如声明一个number类型的变量v_id，那其形式应为：

v_id number;

　　如果给上面的v_id变量赋值，不能用”=”应该用”:=”,即形式为：

v_id :=5;

　　3、控制结构

　　PL/SQL程序段中有三种程序结构：条件结构、循环结构和顺序结构。

　　 条件结构

　　与其它语言完全类似，语法结构如下：

if condition then
statement1
else
statement2
end if ;

　　 循环结构

　　这一结构与其他语言不太一样，在PL/SQL程序中有三种循环结构：

a. loop … end loop;
b. while condition loop … end loop;
c. for variable in low_bound . . upper_bound loop … end loop;

　　其中的“…”代表循环体。

　　 顺序结构

　　实际就是goto的运用，不过从程序控制的角度来看，尽量少用goto可以使得程序结构更加的清晰。

　　4、SQL基本命令

　　PL/SQL使用的数据库操作语言还是基于SQL的，所以熟悉SQL是进行PL/SQL编程的基础。表１-1为SQL语言的分类。

　　表1-1　SQL语言分类

类别 SQL语句
数据定义语言(DDL) Create ,Drop,Grant,Revoke, …
数据操纵语言(DML) Update,Insert,Delete, …
数据控制语言(DCL) Commit,Rollback,Savapoint, …
其他 Alter System,Connect,Allocate, …

　　可以参阅其他关于SQL语言的资料来了解具体的语法结构，这里就不多赘述了。

三、过程与函数

　　PL/SQL中的过程和函数与其他语言的过程和函数的概念一样，都是为了执行一定的任务而组合在一起的语句。过程无返回值，函数有返回值。其语法结构为：
　　过程：Create or replace procedure procname(参数列表) as PL/SQL语句块

　　函数：Create or replace function funcname(参数列表) return 返回值 as PL/SQL语句块

　　这里为了更为方面的说明过程的运用，下面给出一个示例：

　　问题：假设有一张表t1，有f1和f2两个字段，f1为number类型，f２为varchar2类型，然后往t１里写两条记录，内容自定。

Create or replace procedure test_procedure as
V_f11 number :=1; /*声明变量并赋初值*/
V_f12 number :=2;
V_f21 varchar2(20) :=’first’;
V_f22 varchar2(20) :=’second’;
Begin
Insert into t1 values (V_f11, V_f21);
Insert into t1 values (V_f12, V_f22);
End test_procedure; /*test_procedure可以省略*/

　　至此，test_procedure存储过程已经完成，然后经过编译后就可以在其他PL/SQL块或者过程中调用了。由于函数与过程具有很大的相似性，所以这里就不再重复了。

四、游标

　　这里特别提出游标的概念，是因为它在PL/SQL的编程中非常的重要。其定义为：用游标来指代一个DML　SQL操作返回的结果集。即当一个对数据库的查询操作返回一组结果集时，用游标来标注这组结果集，以后通过对游标的操作来获取结果集中的数据信息。定义游标的语法结构如下：

cursor cursor_name is SQL语句;

　　在本文第一段代码中有一句话如下：

cursor c_emp is select * from employee where emp_id=3;

　　其含义是定义一个游标c_emp，其代表着employee表中所有emp_id字段为３的结果集。当需要操作该结果集时，必须完成三步：打开游标、使用fetch语句将游标里的数据取出、关闭游标。请参照本文第一段代码的注释理解游标操作的三步骤。

五、其他概念

　　PL/SQL中包的概念很重要，主要是对一组功能相近的过程和函数进行封装，类似于面向对象中的名字空间的概念。

　　触发器是一种特殊的存储过程，其调用者比较特殊，是当发生特定的事件才被调用，主要用于多表之间的消息通知。

六、调试环境

　　PL/SQL的调试环境目前比较多，除了Oracle自带有调试环境Sql*plus以外，本人推荐TOAD这个工具，该工具用户界面友好，可以提高程序的编制效率。

　　本文主要讲解PL/SQL的基础部分，熟悉这部分内容后可以进行存储过程的编写和应用，对于提高数据库服务器端的执行效率很有帮助。

JavaScript 是目前公认的客户端脚本最强语言，其在客户端的处理能力也使服务器大大的减轻了负担，
其应用的也十分广泛，可以说目前每个网站都或多或少的运用JavaScript ，目前流行的Ajax技术也是
以JavaScript为基础的，本简单教程适合初学都观看，您可以在此对JavaScript进行初步的了解。

对象及对应事件
对象 事件处理程序
Button onClick
Reset onClick
Submit onClick
Radio onClick
Checkbox onClick
Link onClick, onMouseOver , onMouseOut
Form onSubmit, onReset
Text onChange, onFocus, onBlur, onSelect
Textarea onChange, onFocus, onBlur, onSelect
Select onChange, onFocus, onBlur
Image onAbort, onError
Area onClick, onMouseOver , onMouseOut
Window onLoad, onUnLoad, onError