编程基础

Java开发基础

语言基础

浅克隆和深克隆

  • Shallow Clone

    被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即浅克隆仅仅复制所拷贝的对象，而不复制它所引用的对象。

  • Deep Clone

    被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深克隆把要复制的对象所引用的对象复制了一遍。

数据库

SQL 基础

增删改查

  1. INSERT ```sql / 全部字段INSERT / INSERT INTO 表名称 VALUES(值1,值2,…)

/ 部分字段INSERT / INSERT INTO 表名称 (列1,列2,…) VALUES (值1,值2,…)

  1. > 注意：值一定要与字段顺序对应，字符串用引号包含，注意空格，字段名不要引号
  3. 2.  SELECT 
  4. 2.  UPDATE 
  5. ```sql
  6. /* 单字段UPDATE */
  7. UPDATE 表名称 SET 列名称 = 新值 WHERE 条件
  8. /* 多字段UPDATE */
  9. UPDATE 表名称 SET 列1 = 新值1, 列2 = 新值2,... WHERE 条件

UPDATE 之前可以先 SELECT 确认一下数据是否是自己需要修改的数据

  1. DELETE
    1. /* 单行删除 */
    2. DELETE FROM 表名称 WHERE 条件
    3. /* 多行删除 */
    4. DELETE FROM 表名称 WHERE 条件

下面举例说明：

  1. DELETE FROM movies WHERE id = 2  /* 删除 id = 2 的一行数据 */
  2. DELETE FROM movies WHERE id > 2  /* 删除 id > 2 的所有数据 */

和 UPDATE 一样，操作会对数据进行修改，可以先 SELECT 确认一下是否是自己需要删除的数据

基础语法

排序

ORDER BY
可以添加后缀 ASC(升序排列)、DESC(降序排列)，默认为ASC。

表达式

事实上我们在使用SQL语句的过程中也可以使用表达式来指定属性进行一定的计算或者处理，如有一个col_name是出生日期，现在要求SQL返回当前的年龄，这里就可以使用一个表达式来计算时间。表达式可以对数字运算、字符串运算也可以在表达式中只使用常量而不使用col_name。

  1. /* 表达式举例说明 */
  2. SELECT partice_speed / 2.0 AS half_partice_speed    /* 微粒速度除以2.0 */
  3. FROM physics_data
  4. WHERE ABS(particle_position) * 10.0 > 500     /* 条件要求该属性绝对值乘以10.0大于500 */

每一个数据库都有一套函数提供给用户使用，包含常见的数字、字符串、时间等的处理。下面是几个常见的统计函数：

函数 描述
COUNT(*) 统计数据行数
COUNT(column) 统计column非null的行数
MIN(column) 找到column最小的一行
MAX(column) 找到column最大的一行
AVG(column) 对column所有行取平均值
SUM(column) 对column所有行求和

别名

我们在使用表达式的时候可能会出现很长的表达式，这时候语句的可读性就会下降，我们可以使用AS关键字来取一个别名。别名不仅可以用在表达式上也可以用在普通的属性列甚至是表上。

  1. /* 别名 */
  2. SELECT column1 AS particle_speed    /* 取别名，column1的别名为particle_speed */
  3. from physics_data

分组

分组语法可以按照某个col_name对数据进行分组，如对公司支出按照年份或者部门进行分组查询。
GROUP BY分组结果的条数就是分组数量。

  1. /* 数据分组统计 
  2.    每栋办公室按人数排名,不要统计无办公室的雇员 */
  3. SELECT COUNT(*),           /* 统计办公室总人数 */
  4.        building            /* 办公室名 */
  5. FROM employees
  6. WHERE building IS NOT null
  7. GROUP BY building
  8. ORDER BY SUM(building) DESC

查询顺序

如下是一个完整的SELECT查询语句

  1. SELECT DISTINCT column,
  2.     AGG_FUNC(column_or_expression),
  3.     …
  4. FROM mytable
  5.     JOIN another_table
  6.       ON mytable.column = another_table.column
  7.     WHERE constraint_expression
  8.     GROUP BY column
  9.     HAVING constraint_expression
  10.     ORDER BY column ASC/DESC
  11.     LIMIT count OFFSET COUNT;

其中各种语法的顺序需要严格按照规定来编写

  1. FROM 和 JOINs
    FROM 和 JOINs 会在第一个执行，确定整体的数据范围。如果要JOIN不同表，则会生成一个临时表来用于进行下面的过程，总之第一步可以简单理解为确定一个数据源表（含临时表）。
  2. WHERE
    确定了数据来源之后 WHERE 语句就在这个数据源中按照要求来进行数据的筛选，丢弃不符合要求的数据行。AS 别名不能在这个阶段使用，因为可能别名还是一个没有执行的表达式。
  3. GROUP BY
    对数据进行分组、统计，并将结果集缩小为分数组，其他的数据在分组后丢弃
  4. HAVING
    分组之后 HAVING 会对结果集进行筛选。AS别名不能在此阶段使用
  5. SELECT
    确定结果之后，SELECT 用来对结果进行简单筛选或者计算，决定要输出什么数据
  6. DISTINCT
    如果有数据行重复，DISTINCT 负责去除重复内容
  7. ORDER BY
    确定了结果集之后，ORDER BY 对结果进行排序。因为 SELECT 中的表达式已经执行，因此可以使用 AS 别名
  8. LIMIT / OFFSET
    最后 LIMIT 和 OFFSET 从排序的结果中截取部分数据

常用函数

NVL 空值判断函数

  1. NVL (表达式A, 表达式B)
    如果表达式 A 为空值，NVL 返回值为表达式 B 的值，否则返回表达式 A 的值。该函数的目的是把空值转换为一个实际的值。表达式的值可以是数字型、字符型和日期型，但是表达式 A 和 B 的数据类型必须是同一种。
  2. NVL2(表达式A，表达式B，表达式C）
    如果表达式 A 为空，则返回表达式 C 的值；如果表达式 A 不为空则返回表达式 B 的值。

存储过程(DB2)

没有学习的必要，这里作者是因为项目中确实需要用到这东西才去学了，目前已经很少会有公司用这种东西。数据库一般只用来存储数据，减少数据库的负担。存储过程调试修改起来费劲，并且后期难以拓展，不适用于现在的互联网项目。

应用示例

  • 将一个表中的数据复制插入到另一张表里 ```sql CREATE PROCEDURE aaa()—存储过程可以设定输入参数和输出参数 LANGUAGE SQL—DB2可以用多种语言编写存储过程，这里用的是纯SQL BEGIN—开始 DECLARE vID smallint;—定义变量，和Oracle一样 DECLARE 变量名 变量的数据类型; FOR V AS SELECT BRND_CD FROM TMP_BRND_CD—for循环 tmp_brnd_cd预先创建好
    1.   DO--循环体开始
    2.   SET vID=BRND_CD;--对vID赋值，db2可以用set赋值，也可以用values赋值，这里可以写成values(BRND_CD) into vID
    3.   INSERT INTO WWM_FORINSERT_TEST VALUES(vID);--往wwm_forinsert_test表中插入数据
    END FOR;—循环体结束 END —存储过程结束

— 执行存储过程 CALL aaa()

  2. <a name="0b680046"></a>
  3. ### 语法参数说明
  5. - **procedure-name**<br />存储过程的名字
  6. - **{IN | OUT | INOUT parameter-name data-type}** 
  7.    - **IN** 传入参数；
  8.    - **OUT** 输出参数；
  9.    - **INOUT** 输入输出参数；
  10.    - **data-type** 参数类型，可以接收SQL类型和创建的表
  11. - **SPECIFIC specific-name**<br />唯一的特定名称（别名），可以用存储过程名代替，这个特定名称用于drop存储过程，或者给存储过程添加注释用，但不能调用存储过程。如果不指定，数据库会自动生成一个yymmddhhmmsshhn时间戳的名字。
  12. - **DYNAMIC RESULT SETS integer**<br />指定存储过程返回结果的最大数量。存储过程虽然没有return语句，但是可以返回结果集
  13. - **CONTAINS SQL, READS SQL DATA,  MODIFIES SQL DATA**<br />指定存储过程中的SQL访问级别 
  14.    - **CONTAINS SQL** 表示存储过程可以执行中，既不可以读取SQL数据，也不可以修改SQL数据
  15.    - **READS SQL DATA** 表示存储过程可以执行中读取SQL数据，但不可以修改数据
  16.    - **MODIFIES SQL DATA** 表示存储过程中可以执行任何SQL语句
  17. - **DETERMINISTIC or NOT DETERMINISTIC** 表示存储过程时动态的或者非动态的。动态的返回值是不确定的，非动态的每次返回值是相同的
  18. - **CALLED ON NULL INPUT** 表示调用存储过程而不管任何输入参数是否为NULL，并且任何的 OUT 或者 INOUT 参数可以返回一个 NULL 或者非空值。检验参数是否为 NULL 是在过程中进行的
  19. - **INHERIT SPECIAL REGISTERS** 表示继承专用寄存器
  20. - **OLD SAVEPOINT LEVEL or NEW SAVEPOINT LEVEL** 建立存储点，OLD SAVEPOINT LEVEL 是默认的存储点
  21. - **LANGUAGE SQL** 指定程序的主体是用SQL语言
  22. - **EXTERNAL ACTION or NO EXTERNAL ACTION** 表示存储过程是否执行一些改变数据库状态的活动，而不通过数据库管理器管。默认是 EXTERNAL ACTION，如果指定为 NO EXTERNAL ACTION ，则数据库会确定最优化方案
  23. - **PARAMETER CCSID** 指定所有输出字符串数据的编码，默认为UNICODE 编码数据库为PARAMETER CCSID UNICODE，其他数据库默认为 PARAMETER CCSID 3 ASCII
  24. - **SQL-procedure-body** 存储过程的主体
  25. - **AUTONOMOUS** 声明为自治事务
  27. <a name="b7f5c477"></a>
  28. ### 游标
  29. 定义游标
  30. ```sql
  31. DECLARE 游标名 CURSOR FOR SELECT 语句

示例：

  1. DECLARE mycurl CURSOR
  2.     FOR SELECT e.empno, e.lastname, e.job
  3.         FROM employee e, department d
  4.         WHERE e.workdept = d.deptno
  5.             AND deptname = 'PLANTING';

在 SQL 过程中，游标除了迭代结果集中的行，还可以将结果集返回给调用程序或其他过程

  • WITHOUT RETURN / WITH RETURN 选项指定游标的结果表是否作为从一个过程中返回的结果集
  • WITH RETURN TO CALLER 选项指定将来自游标的结果集返回给调用者，后者可以是另一个过程或一个客户机应用程序
  • WITH RETURN TO CLIENT 将来自游标的结果集返回给客户机应用程序，绕过任何中间的嵌套过程
  • WITH HOLD 如果没有加 WITH HOLD，在 Commit 和 RollBack 时游标将会被关闭。
    1. -- 下面是游标声明的几个例子
    2. DECLARE c1 CURSOR FOR SELECT * FROM staff;
    3. -- (DECLARE 关键字, c1游标名称, CURSOR是必须有的,指通过c1的游标来操作staff里所有的数据)
    4. -- 最常用的最普通的
    5. DECLARE c1 CURSOR WITH HOLD FOR SELECT * FROM staff;
    6. DECLARE c1 CURSOR WITH RETURN TO CALLER FOR SELECT * FROM staff;
    7. DECLARE c1 CURSOR WITH RETURN TO CLIENT FOR SELECT * FROM staff;

若要从一个过程中返回结果集，需要：

  1. 创建一个过程，创建时指定 DYNAMIC RESULT SETS 子句中声明存储过程将要返回结果集的数量
  2. 声明游标，声明时指定 WITH RETURN 子句

  3. 打开该游标，并使之保持 open 状态，如果关闭该游标，则结果集将不能返回调用者应用程序

    1. -- 返回一个结果集的游标的声明
    2. CREATE PROCEDURE emp_from_dept()
    3.  DYNAMIC RESULT SETS 1 -- 返回的结果集超出定义的数量会返回一个警告
    4.  P1: BEGIN
    5.      DECLARE c_emp_dept CURSOR WITH RETURN
    6.          FOR SELECT empno, lastname, job, salary, comm
    7.              FROM employee
    8.              WHERE workdept = 'E21';
    10.          OPEN c_emp_dept;
    11.  END P1

条件判断

  1. if 语句 

    1. IF years_of_serv > 30 THEN
    2. SET gl_sal_increase = 15000;
    3. ELSEIF years_of_serv > 20 THEN
    4. SET gl_sal_increase = 12000;
    5. ELSE
    6. SET gl_sal_increase = 10000;
    7. END IF;

  2. CASE 语句

    • simple CASE 语句用于根据一个字面值进入某个逻辑
    • searched CASE 语句用于根据一个表达式的值进入某个逻辑 ```sql — 使用 searched CASE 语句的存储过程 CREATE PROCEDURE sal_increase_lim1 (empid CHAR(6)) BEGIN DECLARE years_of_serv INT DEFAULT 0; DECLARE v_incr_rate DEC(9,2) DEFAULT 0.0;

    SELECT YEAR(CURRENT DATE) - YEAR(hiredate)

    1. INTO years_of_serv
    2. FROM empl1
    3. WHERE empno = empid;

    CASE

    1. WHEN years_of_serv > 30 THEN
    2.     SET v_incr_rate = 0.08;
    3. WHEN years_of_serv > 20 THEN
    4.     SET v_incr_rate = 0.07;
    5. WHEN years_of_serv > 10 THEN
    6.     SET v_incr_rate = 0.05;
    7. ELSE
    8.     SET v_incr_rate = 0.04;

    END CASE;

    UPDATE empl1

    1. SET salary = salary + salary * v_incr_rate

    WHERE empno = empid; END ```

循环

  1. LOOP 循环

    1. CREATE PROCEDURE LEAVE_LOOP (DEPTIN char(3), OUT p_counter INTEGER)
    2. L1: BEGIN
    3.  DECLARE v_at_end, v_counter INTEGER DEFAULT 0;
    4.  DECLARE v_lastname VARCHAR(15);
    5.  DECLARE v_birthd, v_hired DATE;
    7.  DECLARE c1 CURSOR
    8.      FOR SELECT lastname, hiredate, birthdate FROM employee
    9.          WHERE WORKDEPT = deptin;
    11.  DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_at_end = 1;
    13.  OPEN c1;
    14.  FETCH_LOOP: LOOP
    15.  FETCH c1 INTO v_lastname, v_hired, v_birthd;
    16.      IF v_at_end <> 0 THEN    -- LOOP UNTIL LAST  ROW OF the CURSOR
    17.          LEAVE FETCH_LOOP;
    18.      END IF;
    19.      SET v_counter = v_counter + 1;
    20.      INSERT INTO PEPORT_INFO_DEPT
    21.          values(v_lastname, v_hired, v_birthd);
    22.  END LOOP FETCH_LOOP;
    23.  SET p_counter = v_counter;
    24. END L1

  2. WHILE 循环

    1. CREATE PROCEDURE DEPT_REPT (DEPTIN CHAR(3), OUT p_counter INTEGER)
    2. P1: BEGIN
    3.  DECLARE v_at_end, v_counter integer DEFAULT 0;
    4.  DECLARE v_lastname VARCHAR(15);
    5.  DECLARE v_birthd, v_hired DATE;
    7.  DECLARE c1 CURSOR
    8.      FOR SELECT lastname, hiredate, birthdate FROM employee
    9.          WHERE WORKDEPT = deptin;
    11.  DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_at_end = 1;
    13.  OPEN c1;
    14.  FETCH c1 INTO v_lastname, v_hired, v_birthd;
    15.  WHILE (v_at_end = 0)
    16.  DO
    17.      INSERT INTO REPORT_INFO_DEPT
    18.          values(v_lastname, v_hired, v_birthd);
    19.      SET v_counter = v_counter + 1;
    20.      FETCH c1 INTO v_lastname, v_hired, v_birthd;
    21.  END WHILE;
    23.  SET p_counter = v_counter;
    24. END P1

  3. FOR 循环

    1. -- FOR 循环
    2. CREATE PROCEDURE DEPT_REPT1 (DEPTIN CHAR(3), OUT p_counter INT)
    3. P1: BEGIN
    4.  DECLARE v_counter INT DEFAULT 0;
    5.  FOR dept_loop AS
    6.      SELECT lastname, hiredate, birthdate FROM employee
    7.          WHERE WORKDEPT = deptin
    8.  DO
    9.      INSERT INTO REPORT_INFO_DEPT VALUES
    10.          (dept_loop.lastname, dept_loop.hiredate, dept_loop.birthdate);
    11.      SET v_counter = v_counter + 1;
    12.  END FOR;
    13.  SET p_counter = v_counter;
    14. END P1

  4. REPEAT 循环

临时表空间

  1. 要使用临时表必须要创建一个表空间，默认为没有。
  1. -- 创建一个临时表空间
  2. CREATE USER TEMPORARY TABLESPACE usertemp1
  3.     managed BY SYSTEM USING ('usertemp1')
  1. 可以使用  **DECLARE GLOBAL TEMPORARY TABLE** 语句来定义临时表，DB2的临时表是基于会话的，且在会话之间是隔离的。当会话结束时，临时表的数据会被删除，临时表被隐式卸下。对临时表的定义不会  **SYSCAT.TABLES** 中出现。
  1. /*
  2.  * NOT LOGGED 不记录事务日志
  3.  */
  4. DECLARE GLOBAL TEMPORARY TABLE gbl_temp
  5.     LIKE empltab1
  6.     ON COMMIT DELETE ROWS
  7.     NOT logged IN usr_tbsp
  10. /**
  11.  * 方法1：
  12.  * ON COMMIT DELETE ROWS 在提交的时候清空数据，默认属性
  13.  */
  14. DECLARE GLOBAL TEMPORARY TABLE 表名
  15. (
  16.     -- 参数列表
  17.     NAME VARCHAR(10), -- 姓名
  18.     DEPT SMALLINT, -- 部门
  19.     SALARY DEC(7, 2) -- 工资
  20. )
  21. ON COMMIT DELETE ROWS;
  24. /**
  25.  * 方法2：
  26.  * 1. ON COMMIT PRESERVE ROWS 一直到会话结束
  27.  * 2. LIKE 引用表名 INCLUDING COLUMN DEFAULTS WITH REPLACE 字段和类型引用其他表
  28.  */
  29. DECLARE GLOBAL TEMPORARY TABLE 表名
  30. LIKE 引用表名 INCLUDING COLUMN DEFAULTS 
  31. WITH REPLACE
  32. ON COMMIT PRESERVE ROWS;
  35. /**
  36.  * 方法3：
  37.  * DEFINITION ONLY WITH REPLACE 程序结束后自动删除该临时表
  38.  */
  39. DECLARE GLOBAL TEMPORARY TABLE 表名 AS
  40. (
  41.     SELECT * FROM staff WHERE <condition>
  42. )
  43. DEFINITION ONLY WITH REPLACE;
  • 用户定义临时表不支持
    • LOB 类型的列（或基于 LOB 的单值类型列）
    • 用户定义类型列
    • LONG VARCHAR 列
  • 使用表空间 ```sql CONNECT TO SAMPLE@ — Declare a teporary table from CLP — 创建表空间 DECLARE GLOBAL TEMPORARY TABLE temp_employee LIKE employee ON COMMIT PRESERVE ROWS@

— create a procedure which references the temporary table CREATE PROCEDURE p1 RESULT SETS 1

BEGIN — 声明游标 DECLARE cur CURSOR WITH HOLD WITH RETURN TO CLIENT FOR SELECT empno, firstname, lastname FROM SESSION.temp_employee FETCH FIRST 5 ROWS ONLY;

  1. OPEN cur;

END @

— Now from the CLP (an application) — INSERT into the temp table INSERT INTO SESSION.temp_employee SELECT * FROM EMPLOYEE@

— CALL the procedure, which returns an open cursor back to the — CLP, proving that the temp table data was received. CALL p1@

  2. 在上面的例子中，创建 CLP 连接后声明了一个临时表。然后创建了引用临时表的过程 p1。这里要注意的关键是，即使在过程体中没有声明临时表，该过程也被成功创建。
  4. <a name="e449cf10"></a>
  5. ### 异常处理
  7. begin 前声明异常 **DECLARE handler-type HANDLER FOR SQLEXCEPTION \ SQLWARNING | NOT FOUND** 为异常类型，handler-type 处理类型有以下几种：
  9. - UNDO 在处理器执行之前，DB2会回滚存储过程中执行的 SQL 操作。在处理器操作完成之后，存储过程会终止，并将控制返回给调用者
  10. - EXIT 在处理器操作完成之后，存储过程会终止，并将控制返回给调用者
  11. - CONTINUE 在处理器完成之后，会继续执行产生这个异常语句之后的下一条语句
  13. ```sql
  14. DECLARE CONTINUE HANDLER FOR not_found, SQLEXCEPTION 
  15.     SET at_end = 1;
  16. DECLARE CONTINUE HANDLER FOR trunc BEGIN
  17.     SET truncated = 1;
  18.     SET msg = 'message';
  19. END;

需要注意的问题：

  • DB2 存储过程会在 SQL 执行完成后，将返回信息赋值给 SQLCODE 和 SQLSTATE。 这两个DB2 内置变量在使用前需要定义
  • 定义 UNDO 类型的异常处理，在定义后面可以跟上操作语句

  • UNDO 类型的异常处理，必须是处理原子操作的 SQL 块，DB2 默认不是原子操作的。在 BEGIN 跟上 ATOMIC 即可 ```sql CREATE OR REPLACE PROCEDURE TEST ( IN num INTEGER, OUT P_ERRORCODE VARCHAR(256), — SQL 返回信息码 OUT P_ERRORCODE VARCHAR(1024)) — SQL 返回信息 BEGIN ATOMIC

    DECLARE SQLCODE INTEGER DEFAULT 0; DECLARE SQLSTATE CHAR(5) DEFAULT ‘00000’; — 定义一个 UNDO 类型的异常处理 DECLARE UNDO HANDLER FOR SQLEXCEPTION SET P_ERRORCODE = to_char(sqlcode), P_ERRORCODE = ‘处理失败’;

    UPDATE userinfo t SET t.usercode = ‘000000000003’ WHERE t.usercode = ‘000000000002’; UPDATE userinfo t SET t.usercode = ‘00000000000100’ WHERE t.usercode = ‘000000000001’; — 这里会因 usercode 字段超长出现异常

    SET P_ERRORCODE = to_char(abs(SQLCODE)); SET P_ERRORDESC = ‘处理成功’;

END; ```

网络

Cookie 和 Session

cookie session
保存在客户端 保存在服务器端
不够安全，用户就可以进行修改 用户无法修改，较为安全
保存数据的数量以及大小有限制 能够保存大量的数据
只能保存ASCII 字符串 可以存取任意类型的数据

要点：

  • cookie 是实际存在的东西，而 session 可以理解为是一种抽象概念，是用于记录用户的状态、行为等的上下文。
  • session 使用一个 sessionID 来标识用户，一般会将这个 sessionID 存在 cookie 里。可以使用 cookie 也可以使用其他来实现，如在 url 中传递 sessionID。