最近的日志

今日学习总结：
    动态sql
    1.定义: 和多态类似，在运行期间才确定的sql语句。
    2.编程语言通常按照两种方法绑定标识符，早期绑定和晚期绑定。
       绑定，是编译器识别程序中标识符存储位置的过程。
       因为pl/sql是使用早期绑定，所以不能使用DDL和DCL语句。
    3.为了避免硬解析（每次查询提交时先到共享池中检查是否有以前提交过的，没有的经过解析语句、制定执行
      路径、优化访问计划的过程）和提高性能和并发访问量，所以用绑定变量。

    4.select * from employees where id = :v_id;//使用绑定变量。
    5.需要注意的不能用绑定变量替换数据库对的表名、列名等。
    6.使用绑定变量：(下面只适用于返回单行sql查询)
      declare
        v_sql varchar2(4000);//最大40000
      begin
     
       v_sql := 'update employees set salary = salary*2 where employee_id = 206;

       execute immediate v_sql;
      end;

      2>  declare
  v_sql varchar2(1000);
 begin
  v_sql := 'update employees set salary = :salary where employee_id = :no';
   execute immediate v_sql using 1000,206;
 end;//注意using后面的绑定参数跟前面的对应的关系。

今日学习总结：
   补充昨天的动态SQL:在执行动态SQL时两种方式只能取其一（
                      execute immediate sql using 206;
                      type xx is ref cursor;
        x xx;
        open x for sql using 206;
        loop
          x;
        end loop;）

   开发PL/SQL子程序和包

   子程序：存储过程/函数（区别：函数有返回值，用于业务逻辑较复杂的运算）
      存储过程:(示例)
         create or replace procedure p_test(p_name varchar2,p_password varchar2) //注意行参没有长度。
  is/as
  begin
    dbms_output.put_line(p_name||p_password);
  end;
    
     函数：（示例）
        create or replace function p_test(p_name varchar2,p_password varchar2)
   return 数据类型
   is/as
   begin
     pl/sql块;
   end;
    查看函数源代码：select text from user_source where name = 'F_TEST';
    删除函数和存储过程类似：drop function/procedure f_test;

    注意，在为存储过程和函数传参的时候，不能指定长度。
          有三种行参类型：传入、传出和混合参数，在调用时既可以传类型，也可传对应
   的参数名，但是传出参数一定要定义参数来接收值。
   
    开发包：
      1.创建包规范
      create or replace package pkg_test
         is/as
           变量
    子程序
         end pkg_test;
      2.创建包体
        create or replace package body pkg_test
 is/as
    子程序
        end pkg_test;

今日学习总结：

    触发器（用来强制业务规则、数据完整性和一致性的机制）

    作用：在操作数据时执行自定义的操作，或是对表进行校验。

    类型：DML触发器、instead of触发器、系统事件触发器。

    dml触发器：
      before/after/语句级/行级（表级）

      创建触发器：
        create or replace trigger tr_test
 before|after
 insert or update or delete of 列名 on 表名
 for each row(行级)

 begin
   if :new.salary<:old.salary then
     dbms_output.put_line('不能...');
   end if;
 end;

     instead of触发器（视图触发器）

     复杂的视图一般是不能执行DML操作的，但在为视图建立触发器后就可以了。
      
        创建视图：
        create or replace view view_test
 as
 select a.deptno,a.dname,b.empno,b.ename(两个表的字段)
 from dept a, emp b
 where a.deptno=b.deptno

 创建instead of触发器
 create or replace trigger tr_dept_emp
   insert of insert on view_test
   for each row
   begin

   end;

今日学习总结：

    jdbc中应用oracle

    在JDBC中执行PL/SQL的存储过程
      //访问带参数的存储过程
      {call 过程名(?,?)}
      //访问不带参数的存储过程
      {call 过程名}
      //访问返回结果参数的过程
      {?=call 过程名(?,?)}
     //返回游标
      PL/SQL:
        包头：
         create or replace package pkg_test
  is
   type cur_emp is ref curson;
   procedure sp_get_all(p_curson out cur_emp)
  end pkg_test;
        包体：
  create or replace package body pkg_test
  is
   procedure sp_get_all(p_curson out cur_emp)
   is
   begin
            open p_curson for select * from emp;
     //注意不能在这里close游标
   end;
  end pkg_test;

      JDBC:
         Class.forName("oracle驱动");
  Connection conn = DriverManager.getConnection(url,user,password);
  CallableStatement proc = conn.prepareCall({call sp_get_all(?)});
  proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);
  proc.execute();
  rs = (ResultSet)proc.getObject();
  while(rs.next()){
    System.out.println(rs.getString(1));
  }
        
J2EE部分：
今日学习总结：
      struts框架内部组件
1、视图组件
    DTO:数据传输对象;data transfer object.(即javabean)
    DTO:javabean和ActionFormBean它们都起到传输数据、减少冗余、提高传输效率的作用。
   但是，在用时不能互换，因为ActionFormBean是在struts框架中的一部分。
   创建ActionForm:
       静态ActionFormBean:
    1.创建：继承ActionForm，属性和表单中的字段一一对应。
    2.配置：<form-bean name="userForm" type="com.yidu.struts.UserForm"/>
    3.访问:可以被jsp、struts标签、Action和其他组件访问;
      可以保存在HttpServletRequest和Httpsession对象中：
      request.setAttribut("userForm",userForm对象);
      在jsp中访问：${userForm.属性}
   
      动态ActionForm:
    1.创建：继承DynaActionForm类。
    2.配置：<form-bean name="userForm" type="org.apatche.struts.action.DynaActionForm"/>
            <form-property name="txtUserName" type="java.lang.String" />
    3.访问：DynaActionForm daf = (DynaActionForm)form;
            String userName = (String)daf.get("txtUserName");
    页面中访问：${userForm.map["txtUserName"]}
 
 终极版：将bean作为ActionForm的属性，生成get/set方法。
    创建方法和配置方法和一类似，用于表单中字段很多的情况下
    jsp:  user.属性。

2.控制器组件
  struts框架的几个类：ActionServlet、ActionMapping、ActionForm、Action、ActionForward
     这个顺序也是一个请求的过程。

3.模型组件

 
今日学习总结：
    struts标签库与外部组件

 struts标签库：html、Bean、Logic标签库
     html标签库:
       1.导入标签库<%@ tablig uri="http://struts.apache.jst/html" prefix="html"%>
       2.<html:html></html:html>
     Bean标签库：
       1.标签只能访问作用域。
       2。example:
          <bean:define> = <c:set>
   <bean:size id="listsize" collection="${list}"/>
     Logic标签库:(逻辑标签库)
       <logic:iterate>

 tiles框架：
   <jsp:include>用法
    <jsp:include page="logo.jsp">
    <jsp:include page="footer.jsp">
  
   tiles用法：
     1.创建tiles模版:template.jsp
       <tiles:insert attribute="login"/>
       <tiles:insert attribute="footer"/>
     2.向模版传递参数：index.jsp
       <tiles:insert page="template.jsp" flush="true">
         <tiles:insert name="logo" value="logo.jsp" />
  <tiles:insert name="footer" value="footer.jsp" />
       </tiles:insert>
     3.配置tiles组件：tiles-component.xml
       见书本67页。

  validator验证框架：
      主要两个配置：两个规则文件、和服务器端验证的配置。
        两个规则文件：拷到WEB-INF下，然后在struts-config.xml中引入。
 服务器端验证：validation.xml
    1.绑定form
      <form-validation>
  <formset name="bean">
    <form property="表单元素" depends="是否为空，长度等">
      <arg key="配置属性文件的name">
    </form>
  </formset>
      </form-validation>

      2.在属性文件中配置提示信息。
      
      
 今日学习总结：
    struts与ajax集成
 1.ajax回顾：1+2==一个对象，两个方法
    创建ajax引擎XMLHttpRequest
    利用该对象发送请求到服务器
    根据服务器的响应结果回调。
 2.在struts中应用ajax:
    在页面中发送请求到服务器，
  区别：引擎对象为局部变量，将回调方法与处理响应方法分离，有利用传参数，和回调参数的重用。
        提交方式不一样，用post。然后配置Action就可以了。
     
 今日学习总结：
     2009-12-15

     Hibernate关系-映射

  1.概念：ORM:object relational mapping.
    实体与关系型数据库的关系：
       类----表
       对象----记录
       属性-----字段
  2.Hibernate是一个轻量级组件，是一种ORM框架技术。
  3.Hibernate核心API:
    Configuraction  SessionFactory  session Transaction (Query Criteria)

  4.Hibernate的一个HelloWorld:
    步骤：
      1.创建配置文件
         一般在添加工具包进来后就自带一个hibernate.cfg.xml文件，
  在里面添加<hibernate-configurcation>节点里，添加<property name="connection">
  这是由dtd头所决定的，一定要按照它的规则写。注意跟后面的映射文件的区别。

      2.创建PoJO
        没有技术含量。（即一个实体User）
 get/set方法

      3.创建数据库(也没有技术含量)
        create talble tb_user(不能用user，可能是oracle里的关键字吧)
 （
  id number(3);
  name varcha2(20),
  password varchar2(20)
 ）;
      4.创建实体与数据库的映射：
        命名规则：
   表名.hbm.xml
  （节点的配置也是按dtd来约定的，这样hibernate才能关联）
       <hibernate-mapping>
         <class="实体bean" table="对应的表名">
    <id name="对应实体的主键">
  <column name="数据库的主键字段"/>
  <gernator class="assigned"（生成主键的方式） />
  或是 <gernator class="sequence"（生成主键的方式）>
   <param name="sequence">seq_user</param>
       </gernator>
    </id>
    <property name="数据库对应实体的属性"/>
       <column name="对应数据库的字字段" />

       5。根据Hibernate api操作
          Configurcation cf = new Configurcation().config();//加载配置文件，一定要加上方法，如不加的话加载映射文件的。
   //创建SessionFactory
   SessionFactory sf = cf.BuildingSessionFactory();
   //创建session并打开
   Session session = sf.openSession();
   //开始一个事务
   Transaction tr = null;
   //提交事务
   session.getTransaction().commit();
   //关闭
   session.close();

   多对一的映射：（product--category）
     实现的原理：
         多对一的关系主要是体现在数据库，多个产品同属不同类别，而一个类别可以属于几个产品。
       如果要通过查询Product而得到它的类别，是通过主外键来关联它们的。
     
      那么怎样建立orm呢？
         1.把实体Category作为Product的属性，生成get/set方法。
     当然Category属性中已经包括了categoryID了,所以不能单独拿出来，这一点很重要！！
  2.配置：(多的这一映射文件下配)
    <many-to-one name="被包含实体的名称"（private Category category）>那么就填category,注意大小写。
       class="即name里放入的是什么类型的数据" ，这里放的是类别，所以填入实体完整的名称：com.yidu.bean.Category
       column="从表中的外键" >
  3.调用：
    Product p = (Product)session.get(Product.class,"查询条件");
    p.getCategory().getCategroyName();//通过产品杳询类别表的的类别名称。
    
   一对多的映射：（Category--Product）
        功能：查询一个类别下有哪些商品。

 区别：
   1.在一这个实体中将多的实体作为属性，返回一个set.
     在com.yidu.bean.Category中添加：
       Set products = new HashSet();
      set/get;
   2.配置：（在一的这映射文件下配置）
     <set name="product(包含的实体的名称)"
       <key column="从表的外键"（引用主表的字段）
       <one-to-many class="上面name里存放的类型(set里放的类型--product的路径：com.yidu.bean.Product)">
     
  
    多对多的映射：（product--supply）
        体现：通过中间表将它们连接起来，以便于操作和使用。

 区别：
   1、两个实体互相为属性，并把结果放入一个set里。
   2、配置映射文件为互相都要配置：
      在Product.hbm.xml:
         <set name="所包含的实体的名称" table="所对应的表名">
    <key column="自己主键的列名"/>
     <many-to-many class="包含实体的路径或名称" column="对应的主键列名">

  3、调用：
      Product p = (Product)get(Product.class,"条件");
      Set s = p.getSuppy();

      for(Iterator ite =s.iterator();ite.hasenext() ){
  Supplys supplys = (Supplys)ite.next();
  supplys.getSupplyName();
      }