Move Method 搬移函数

你的程序中，有个函数与其所驻类之外的另一个类进行更多交流：调用后者，或被后者调用

在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或者将旧函数完全移除。

Move Field 搬移字段

某个字段被其所驻类之外的另一个类更多地用到。

如果我需要对类做许多处理，保持小步前进是有帮助的。

Extract Class 提炼类

某个类做了应该由梁格磊做的事。可以分别加锁。

• 数据与某些函数总是一起出现
• 子类化方式

Extract Class 是改善并发程序的一种常用技术。

Inline Class 将类内联化

某个类没有做太多事情

Hide Delegate 隐藏“委托关系”

客户通过一个委托类来调用另一个对象。

在服务类上建立客户所需要的所有函数，用以隐藏委托关系

Remove Middle Man 移除中间人

某个类做了过多的简单委托动作

让客户直接调用受托类（受托类特性越来越多）

Introduce Foreign Method 引入外加函数

你需要为提供服务的类增加一个函数，但你无法修改这个类

在客户类中建立一个函数，并以第一参数形式传入一个服务类实例。

Introduce Local Extension 引入本地扩展

你需要为服务类提供一些额外的函数，但你无法修改这个类

建立一个新类，使它包含这些额外函数。让这个扩展品成为源类的子类或包装类。

说明

• 《重构-改善既有代码的设计》Martin Fowler 摘要： 第七章 在对象之间搬移特性

• 欢迎修改，地址：https://github.com/txidol/txidol.github.io

• 你也可以访问：http://txidol.github.io 获取更多的信息

java.util.Collections 集合帮助类

示例程序(JUnit演示)

排序

    @Test
    public void testSort() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));
        assertEquals(3, demoList.get(0).intValue());

        //public static <T extends Comparable<? super T>> void sort(List<T> list)
        Collections.sort(demoList);

        assertEquals(1, demoList.get(0).intValue());

        //public static void shuffle(List<?> list) // 随机排序
        //public static void reverse(List<?> list) // 反序          
    }

查找

    @Test
    public void testBinarySearch() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));
        //必须先排序
        Collections.sort(demoList);
        assertEquals(1, demoList.get(0).intValue());

        //二分查找位置
        //public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
        assertEquals(0, Collections.binarySearch(demoList, 1));

        //public static int indexOfSubList(List<?> source, List<?> target)
        // public static int lastIndexOfSubList(List<?> source, List<?> target)
    }

置换

    @Test
    public void testSwap() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));

        //public static void swap(List<?> list, int i, int j)
        Collections.swap(demoList, 0, 2);
        assertEquals(1, demoList.get(0).intValue());
        //public static void rotate(List<?> list, int distance)  //指定距离轮换
        //public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)  //指定替换
    }

拷贝

    @Test
    public void testCopy() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));

        //public static <T> void copy(List<? super T> dest, List<? extends T> src)
        //注意目的List的size最少要等于src的size
        List<Integer> copyList = new ArrayList<Integer>(Arrays.asList(1, 2, 3));
        Collections.copy(copyList, demoList);
        assertEquals(3, copyList.size());
        assertEquals(3, copyList.get(0).intValue());

        copyList.add(4);
        assertEquals(3, demoList.size());
    }

比较

    @Test
    public void testCompary() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));
        assertEquals(1, Collections.min(demoList).intValue());
        assertEquals(3, Collections.max(demoList).intValue());

        List<Integer> compareList = new ArrayList<Integer>(Arrays.asList(5, 6, 7));
        //Returns true if the two specified collections have no elements in common
        assertTrue(Collections.disjoint(demoList, compareList));
    }

创造不同的集合

    @SuppressWarnings("unused")
    @Test
    public void testCreate() {
        List<Integer> demoList = new ArrayList<Integer>(Arrays.asList(3, 2, 1));

        //空对象 size=0  无添加方法
        List<Integer> emptyList = Collections.emptyList();

        //返回一个只包含指定对象的不可变列表。
        List<Integer> singletonList = Collections.singletonList(1);

        //返回指定列表的一个动态类型安全视图。
        List<Integer> checkedList = Collections.checkedList(demoList, Integer.class);

        //返回指定列表的不可修改视图。
        List<Integer> unmodifiableList = Collections.unmodifiableList(demoList);

        //返回指定列表支持的同步（线程安全的）列表。
        List<Integer> synchronizedList = Collections.synchronizedList(demoList);

        synchronized (synchronizedList) {
            Iterator<Integer> i = synchronizedList.iterator(); // Must be in synchronized block
            while (i.hasNext())
                i.next();
        }

        //map set sortedMap sortedSet
    }

环境 jdk1.6 window7 junit4

Arrays 数组帮助类

示例程序(JUnit演示)

数组转化为List

    @Test
    public void testUserArraysChangeArraytoList() {
        // 类Arrays
        // public static <T> List<T> asList(T... a) 
        // Returns a fixed-size list backed by the specified array

        List<Integer> testList = Arrays.asList(1, 2, 3);
        assertEquals("生成大小为3的List", 3, testList.size());

        List<Integer> testList1 = Arrays.asList(1, 2);
        assertEquals("生成大小为2的List", 2, testList1.size());
    }

    @Test(expected = UnsupportedOperationException.class)
    public void isFixedList() {
        // 类Arrays
        // public static <T> List<T> asList(T... a) 
        // Returns a fixed-size list backed by the specified array
        Integer[] test = {1,2,3};
        List<Integer> testList = Arrays.asList(test);
        assertEquals("生成大小为3的List", 3, testList.size());
        testList.add(4);//throw UnsupportedOperationException
    }

排序

    @Test
    public void testSort() {
        // 类Arrays
        // void java.util.Arrays.sort(Object[] a)
        // 排序
        Integer[] test = {3,2,1};
        Arrays.sort(test);
        assertEquals( 1, test[0].intValue() );

    }

其他方法

    @Test
    public void testEquals() {  
        Integer[] test1 = {3,2,1};
        Integer[] test2 = {3,2,1};  
        Integer[] test3 = {1,2,3};  

        //equals
        assertTrue(Arrays.equals(test1, test2));
        assertFalse(Arrays.equals(test1, test3));

        //toString
        assertEquals( "[3, 2, 1]", Arrays.toString(test1) );

        //copyOf
        assertEquals( "[3, 2]", Arrays.toString(Arrays.copyOf(test1, 2)) );

        //fill
        Arrays.fill(test1, 2);
        assertEquals( "[2, 2, 2]", Arrays.toString(test1) );
    }

环境 jdk1.6 window7 junit4

SQL 触发器

触发器在数据库里以独立的对象存储，它与存储过程和函数不同的是，存储过程与函数需要用户显示调用才执行，而触发器是由一个事件来启动运行。即触发器是当某个事件发生时自动地隐式运行。并且，触发器不能接收参数。所以运行触发器就叫触发或点火（firing）。ORACLE事件指的是对数据库的表进行的INSERT、UPDATE及DELETE操作或对视图进行类似的操作。ORACLE将触发器的功能扩展到了触发ORACLE，如数据库的启动与关闭等。所以触发器常用来完成由数据库的完整性约束难以完成的复杂业务规则的约束，或用来监视对数据库的各种操作，实现审计的功能。

注意事项：

• 触发器不接受参数。
• 一个表上最多可有12个触发器，但同一时间、同一事件、同一类型的触发器只能有一个。并各触发器之间不能有矛盾。
• 在一个表上的触发器越多，对在该表上的DML操作的性能影响就越大。
• 触发器最大为32KB。若确实需要，可以先建立过程，然后在触发器中用CALL语句进行调用。
• 在触发器的执行部分只能用DML语句（SELECT、INSERT、UPDATE、DELETE），不能使用DDL语句（CREATE、ALTER、DROP）。
• 触发器中不能包含事务控制语句(COMMIT，ROLLBACK，SAVEPOINT)。因为触发器是触发语句的一部分，触发语句被提交、回退时，触发器也被提交、回退了。
• 在触发器主体中调用的任何过程、函数，都不能使用事务控制语句。
• 在触发器主体中不能申明任何Long和blob变量。新值new和旧值old也不能向表中的任何long和blob列。
• 不同类型的触发器(如DML触发器、INSTEAD OF触发器、系统触发器)的语法格式和作用有较大区别。

创建触发器的一般语法

CREATE [OR REPLACE] TRIGGER trigger_name
{BEFORE | AFTER }
{INSERT | DELETE | UPDATE [OF column [, column …]]}
[OR {INSERT | DELETE | UPDATE [OF column [, column …]]}...]
ON [schema.]table_name | [schema.]view_name 
[REFERENCING {OLD [AS] old | NEW [AS] new| PARENT as parent}]
[FOR EACH ROW ]
[WHEN condition]
PL/SQL_BLOCK | CALL procedure_name;

问题：当触发器被触发时，要使用被插入、更新或删除的记录中的列值，有时要使用操作前、 后列的值.

:NEW 修饰符访问操作完成后列的值
:OLD 修饰符访问操作完成前列的值        

示例

建立一个触发器, 当职工表 emp 表被删除一条记录时，把被删除记录写到职工表删除日志表中去

CREATE OR REPLACE TRIGGER tr_del_emp 
    BEFORE DELETE --指定触发时机为删除操作前触发
    ON scott.emp 
    FOR EACH ROW   --说明创建的是行级触发器 
    BEGIN
        --将修改前数据插入到日志记录表 del_emp ,以供监督使用。
        INSERT INTO emp_his(deptno , empno, ename , job ,mgr , sal , comm , hiredate )
        VALUES( :old.deptno, :old.empno, :old.ename , :old.job,:old.mgr, :old.sal, :old.comm, :old.hiredate );
    END;

SQL 存储过程

存储过程创建语法：

create or replace procedure 存储过程名（param1 in type，param2 out type） 
as 
    变量1 类型（值范围）; --vs_msg   VARCHAR2(4000); 
    变量2 类型（值范围）;
Begin
    Select count(*) into 变量1 from 表A where列名=param1；
    If (判断条件) then
        Select 列名 into 变量2 from 表A where列名=param1；
        Dbms_output。Put_line(‘打印信息’);
    Elsif (判断条件) then
        Dbms_output。Put_line(‘打印信息’);
    Else
       Raise 异常名（NO_DATA_FOUND）;
    End if;
    Exception
        When others then
        Rollback;
End;

注意事项：

• 存储过程参数不带取值范围，in表示传入，out表示输出 类型可以使用任意Oracle中的合法类型。
• 变量带取值范围，后面接分号
• 在判断语句前最好先用count（*）函数判断是否存在该条操作记录
• 用select 。。。into。。。给变量赋值
• 在代码中抛异常用 raise+异常名

实例

CREATE OR REPLACE PROCEDURE存储过程名
    (
    --定义参数
    is_ym  IN CHAR(6) ,
    the_count OUT NUMBER,
    ) 
AS 
    --定义变量 
    vs_msg   VARCHAR2(4000);   --错误信息变量
    vs_ym_beg  CHAR(6);      --起始月份
    vs_ym_end  CHAR(6);      --终止月份
    vs_ym_sn_beg CHAR(6);     --同期起始月份
    vs_ym_sn_end CHAR(6);     --同期终止月份
    --定义游标(简单的说就是一个可以遍历的结果集) 
    CURSOR cur_1 IS 
    SELECT 。。。 
    FROM 。。。 
    WHERE 。。。
    GROUP BY 。。。; 
BEGIN 
    --用输入参数给变量赋初值，用到了Oralce的SUBSTR TO_CHAR ADD_MONTHS TO_DATE 等很常用的函数。 
    vs_ym_beg := SUBSTR(is_ym,1,6); 
    vs_ym_end := SUBSTR(is_ym,7,6); 
    vs_ym_sn_beg := TO_CHAR(ADD_MONTHS(TO_DATE(vs_ym_beg,'yyyymm'), -12),'yyyymm'); 
    vs_ym_sn_end := TO_CHAR(ADD_MONTHS(TO_DATE(vs_ym_end,'yyyymm'), -12),'yyyymm'); 
    --先删除表中特定条件的数据。 
    DELETE FROM 表名 WHERE ym = is_ym; 
    --然后用内置的DBMS_OUTPUT对象的put_line方法打印出影响的记录行数，其中用到一个系统变量SQL%rowcount 
    DBMS_OUTPUT.put_line('del上月记录='||SQL%rowcount||'条'); 

    INSERT INTO表名(area_code,ym,CMCODE,rmb_amt,usd_amt) 
    SELECT area_code,is_ym,CMCODE,SUM(rmb_amt)/10000,SUM(usd_amt)/10000 
    FROM BGD_AREA_CM_M_BASE_T 
    WHERE ym >= vs_ym_beg 
    AND ym <= vs_ym_end 
    GROUP BY area_code,CMCODE; 

    DBMS_OUTPUT.put_line('ins当月记录='||SQL%rowcount||'条'); 
    --遍历游标处理后更新到表。遍历游标有几种方法，用for语句是其中比较直观的一种。
    FOR rec IN cur_1 LOOP 
        UPDATE 表名
        SET rmb_amt_sn = rec.rmb_amt_sn,usd_amt_sn = rec.usd_amt_sn 
        WHERE area_code = rec.area_code 
        AND CMCODE = rec.CMCODE 
        AND ym = is_ym; 
    END LOOP; 
    COMMIT; 


    --错误处理部分。OTHERS表示除了声明外的任意错误。SQLERRM是系统内置变量保存了当前错误的详细信息。 
    EXCEPTION 
        WHEN OTHERS THEN 
            vs_msg := 'ERROR IN xxxxxxxxxxx_p('||is_ym||'):'||SUBSTR(SQLERRM,1,500);
    ROLLBACK; 
    --把当前错误记录进日志表。 
    INSERT INTO LOG_INFO(proc_name,error_info,op_date) 
        VALUES('xxxxxxxxxxx_p',vs_msg,SYSDATE); 
    COMMIT; 
RETURN; 
END;

更多语法

1 、判断语句:

if 比较式 then begin end; end if;

create or replace procedure test(x in number) is 
begin 
    if x >0 then 
        begin 
        x := 0 - x; 
        end; 
    end if; 
    if x = 0 then 
        begin 
        x: = 1; 
        end; 
    end if; 
end test; 

2 、For 循环

For ... in ... LOOP 
-- 执行语句 
end LOOP; 

(1) 循环遍历游标

create or replace procedure test() as 
Cursor cursor is select name from student; name varchar(20); 
begin 
    for name in cursor LOOP 
        begin 
        dbms_output.putline(name);  
        end; 
    end LOOP; 
end test; 

(2) 循环遍历数组

create or replace procedure test(varArray in myPackage.TestArray) as 
--( 输入参数varArray 是自定义的数组类型，定义方式见标题6) 
i number; 
begin 
    i := 1;  -- 存储过程数组是起始位置是从1 开始的，与java 、C 、C++ 等语言不同。因为在Oracle 中本是没有数组的概念的，数组其实就是一张 
    -- 表(Table), 每个数组元素就是表中的一个记录，所以遍历数组时就相当于从表中的第一条记录开始遍历 
    for i in 1..varArray.count LOOP      
        dbms_output.putline('The No.'|| i || 'record in varArray is:'||varArray(i));    
    end LOOP; 
end test; 

3 、While 循环

while 条件语句 LOOP

begin 
end; 
end LOOP; 

E.g

create or replace procedure test(i in number) as 
begin 
    while i < 10 LOOP 
    begin     
    i:= i + 1; 
    end; 
    end LOOP; 
end test; 

4 、数组

首先明确一个概念：Oracle 中本是没有数组的概念的，数组其实就是一张表(Table), 每个数组元素就是表中的一个记录。

使用数组时，用户可以使用Oracle 已经定义好的数组类型，或可根据自己的需要定义数组类型。

(1) 使用Oracle 自带的数组类型

x array; -- 使用时需要需要进行初始化 

e.g:

create or replace procedure test(y out array) is 
x array;   
begin 
    x := new array(); 
    y := x; 
end test; 

(2) 自定义的数组类型 ( 自定义数据类型时，建议通过创建Package 的方式实现，以便于管理)

create or replace package myPackage is 
Public type declarations   type info is record(     name varchar(20),     y number); 
type TestArray is table of info index by binary_integer;   
-- 此处声明了一个TestArray 的类型数据，其实其为一张存储Info 数据类型的Table 而已，及TestArray 就是一张表，有两个字段，一个是name ，一个是y 。需要注意的是此处使用了Index by binary_integer 编制该Table 的索引项，也可以不写，直接写成：type TestArray is 
table of info ，如果不写的话使用数组时就需要进行初始化：varArray myPackage.TestArray; varArray := new myPackage.TestArray(); 
end TestArray; 

5. 游标的使用 Oracle 中Cursor 是非常有用的，用于遍历临时表中的查询结果。其相关方法和属性也很多，现仅就常用的用法做一二介绍：

(1)Cursor 型游标( 不能用于参数传递)

create or replace procedure test() is   
cusor_1 Cursor is select std_name from student where  ...;  --Cursor 的使用方式1   cursor_2 Cursor; 
begin 
select class_name into cursor_2 from class where ...;  --Cursor 的使用方式2 
可使用For x in cursor LOOP .... end LOOP; 来实现对Cursor 的遍历 
end test; 

(2)SYS_REFCURSOR 型游标，该游标是Oracle 以预先定义的游标，可作出参数进行传递

create or replace procedure test(rsCursor out SYS_REFCURSOR) is 
cursor SYS_REFCURSOR; 
name varhcar(20); 
begin 
OPEN cursor FOR select name from student where ... --SYS_REFCURSOR 只能通过OPEN 方法来打开和赋值 
LOOP 
fetch cursor into name   --SYS_REFCURSOR 只能通过fetch into 来打开和遍历 exit when cursor%NOTFOUND;              --SYS_REFCURSOR 中可使用三个状态属性：                                         ---%NOTFOUND( 未找到记录信息) %FOUND( 找到记录信息)                                         ---%ROWCOUNT( 然后当前游标所指向的行位置) 
dbms_output.putline(name); 
end LOOP; 
rsCursor := cursor; 
end test; 

SQL 函数

SQL 拥有很多可用于计数和计算的内建函数。

SQL Aggregate 函数

SQL Aggregate 函数计算从列中取得的值，返回一个单一的值。

有用的 Aggregate 函数：

• AVG() - 返回平均值
• COUNT() - 返回行数
• FIRST() - 返回第一个记录的值
• LAST() - 返回最后一个记录的值
• MAX() - 返回最大值
• MIN() - 返回最小值
• SUM() - 返回总和

SQL Scalar 函数

SQL Scalar 函数基于输入值，返回一个单一的值。

有用的 Scalar 函数：

• UCASE() - 将某个字段转换为大写
• LCASE() - 将某个字段转换为小写
• MID() - 从某个文本字段提取字符
• LEN() - 返回某个文本字段的长度
• ROUND() - 对某个数值字段进行指定小数位数的四舍五入
• NOW() - 返回当前的系统日期和时间
• FORMAT() - 格式化某个字段的显示方式

GROUP BY

根据一个或多个列对结果集进行分组。

HAVING

（Aggregate聚集函数）分组条件

语法

SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
HAVING aggregate_function(column_name) operator value;

示例

SELECT Employees.LastName, COUNT(Orders.OrderID) AS NumberOfOrders FROM (Orders
INNER JOIN Employees
N Orders.EmployeeID=Employees.EmployeeID)
GROUP BY LastName
HAVING COUNT(Orders.OrderID) > 10;