คือ การปรับปรุงโครงสร้างภายในของโปรแกรมที่มีอยู่ในปัจจุบัน โดยไม่กระทบพฤติกรรมของโปรแกรมนั้น หรือพูดอีกนัยหนึ่ง Refactoring ก็คือ ชุดของการเปลี่ยนแปลงรูปแบบเล็ก ๆ หลาย ๆ รูปแบบ โดยแต่ละรูปแบบเล็ก ๆ นั้นไม่กระทบพฤติกรรมของโปรแกรมส่วนนั้นๆ ทำไมถึงต้องเป็นการเปลี่ยนแปลงเล็ก ๆ เหตุผลก็เพื่อลดโอกาสที่้การเปลี่ยนแปลงนั้นจะกระทบการทำงานของระบบให้มากที่สุดนั่นเอง
มีการอธิบายขบวนการทำ Refactoring ในแต่ละรูปแบบ ไว้แล้ว ดังนี้ (ที่มา : http://www.refactoring.com/catalog/index.html)
- Add Parameter
- Change Bidirectional Association to Unidirectional คือ การเปลี่ยนความสัมพันธ์ระหว่าง class 1 และ class 2 จากติดต่อกันได้ 2 ทาง เป็นติดต่อได้ทางเดียว คือ เปลี่ยนจากสามารถติดต่อทั้งขาไปและขากลับ ระหว่าง class 1 และ class 2 เป็น ติดต่อได้ทางเดียวคือ ติดต่อจาก class 1 ไปหา class 2 เท่านั้น เพราะ class 2 ไม่ต้องการติดต่อกลับไปหา class 1 หรือก็คือไม่ต้องการ feature ใด ๆ จาก class 1 นั่นเอง
- Change Reference to Value คือ เปลี่ยนการส่งผ่านค่าของ object จากแบบ reference เป็นแบบ value ด้วยเหตุผลที่ว่า object นั้น เล็ก เปลี่ยนรูปไม่ได้ และจัดการยาก
- Change Unidirectional Association to Bidirectional คือ การเปลี่ยนความสัมพันธ์ระหว่าง class 1 และ class 2 จากติดต่อกันทางเดียว เป็นติดต่อได้ทั้งสองทาง คือ เปลี่ยนจากสามารถติดต่อเฉพาะขาไป หรือเฉพาะขากลับ ระหว่าง class 1 และ class 2 เป็น ติดต่อได้ทั้งสองทางคือ ติดต่อจาก class 1 ไปหา class 2 ได้ และติดต่อจาก class 2 ไปหา class 1 ก็ได้ด้วย เหตุผลเพราะทั้งสอง class ต่างต้องการ feature จากอีก class หนึ่งนั่นเอง
- Change Value to Reference คือ เปลี่ยนการส่งผ่านค่าของ instants ซึ่งมีค่าเท่ากัน จากการส่งแบบ value เป็นส่งแบบ reference ด้วยเหตุผลที่ว่า instant นั้น ถูกส่งผ่านค่าหลายครั้งมาก
- Collapse Hierarchy คือ การ merge super class กับ sub class เข้าด้วยกัน ด้วยเหตุผลที่ว่า ทั้งสอง class ไม่มีความแตกต่างกัน มากนัก
- Consolidate Conditional Expression คือการรวมหลาย ๆ conditional tests เข้าด้วยกัน เพื่อให้เป็น single conditional expression ด้วยเหตุผลที่ว่าการรวมกันนั้นไม่ทำให้ผลลัพธ์เปลี่ยนแปลง
- Consolidate Duplicate Conditional Fragments คือ การย้าย fragment ที่เหมือนกัน ของ code ซึ่งปรากฎอยู่ในหลาย ๆ branches ของ conditional expression นั้น โดยทำการย้ายออกไปจาก expression นั้น
- Convert Dynamic to Static Construction
- Convert Static to Dynamic Construction
- Decompose Conditional คือการใช้ Extract method ในการแก้ปัญหาคำสั่ง if-then-else โดย extract แต่ละส่วนออกมาเป็นแ้ต่ละ method
- Duplicate Observed Data คือ การทำสำเนาข้อมูลจาก data domain ไปไว้ใน object domain แล้วทำการ set up ให้ observer รู้จักข้อมูลทั้งสองที่ เพื่อแก้ปัญหาที่มีบางข้อมูลใน domain data ซึ่ง available เฉพาะกับ GUI control เท่านั้น
- Eliminate Inter-Entity Bean Communication
- Encapsulate Collection คือ การทำให้ method เป็นแบบอ่านได้อย่างเดียว พร้อมเพิ่มให้มี add และ remove method เพื่อจัดการกับบางข้อมูลในกลุ่ม เพื่อแก้ปัญหาที่มีบาง method คืนค่าข้อมูลออกมาทั้งกลุ่ม
- Encapsulate Downcast เนื่องจาก method ทำการ return ค่าเป็น object ซึ่งผู้เรียกใช้ method นี้ไม่ต้องการ จึงต้องทำการกำจัดโดยย้ายคำสั่งใน object นี้ กลับไปไว้ใน method ดังกล่าว
- Encapsulate Field คือการทำให้ public field เป็น private field พร้อมกำหนดให้มี accessors
- Extract Class คือการสร้าง class ใหม่ พร้อมทั้งย้าย fields และ methods ที่เกี่ยวข้องจาก class เก่ามาไว้ใน class ใหม่นี้
- Extract Interface คือ การ extract กลุ่มของบางส่วนของ class มาเป็น interface ของ class นั้น ด้วยเหตุผลว่ากลุ่มนี้ถูกเรียกใช้อยู่บ่อยๆ
- Extract Method คือ การ extract บางส่วนของ method ออกมาสร้างเป็น method ใหม่ เพื่อทำงานเฉพาะอย่าง
- Extract Package
- Extract Subclass คือ การแยกบางส่วนของ class เดิม ไปสร้างเป็น sub class ของ class นั้น เนื่องจากมีหลายครั้งที่การทำงานเกิดขึ้นกับเฉพาะส่วนที่แยกมาเป็น sub class เท่านั้น
- Extract Superclass คือ การ extract ส่วนที่เหมือนกันของ 2 class มาสร้างเป็น super class ของทั้ง 2 class นั้น
- Form Template Method เนื่องจากมี 2 sub class ของ super class เดียวกัน มีลำดับการทำงานเหมือนกัน แต่มีบาง step การทำงานที่แตกต่างกัน จึงแก้ปัญหานี้ โดยรวม step ที่แตกต่างกัน ของทั้งสอง sub class นั้นสร้างเป็น method ไว้ใน subclass นั้น ๆ เช่น รวม step ที่ sub class 1 ต่างจาก sub class 2 สร้างเป็น method ไว้ใน sub class 1 และเช่นกัน รวม step ที่ sub class 2 ต่างจาก sub class 1 สร้างเป็น method ไว้ใน sub class 2 และหลังจากนั้น ก็รวม step ที่เหมือนกันของทั้งสอง sub class โดย pull up ขึ้นไปสร้างเป็น method ไว้ใน super class เพื่อให้ sub class ที่สร้างใหม่ในทั้ง 2 sub class เรียกใช้ร่วมกันได้
- Hide Delegate เนื่องจากมีบาง class บนเครื่อง client เรียกใช้ delegate class ของ object จึงต้องทำการ refactoring โดย สร้าง method ใหม่ ไว้บน server เพื่อซ่อน delegate class ดังกล่าว
- Hide Method เนื่องจากมีบาง method ของ class ใด ๆ ไม่เคยถูกเรียกใช้จาก class อื่นเลย ดังนั้นจึงทำการแก้ไขโดย กำหนดให้ method นั้นมีการเข้าถึงแบบ private
- Hide presentation tier-specific details from the business tier
- Inline Class เนื่องจากมีบาง class ที่ไม่ค่อยได้ถูกใช้งาน จึงไม่ควรสร้างเป็น class อีกต่อไป จึงแก้ปัญหาโดย ยุบ class นั้นแล้วไปสร้างเป็นองค์ประกอบใน class ที่เกี่่ยวข้องแทน
- Inline Method เนื่องจากมีบาง method ที่ชัดเจนจนไม่จำเป็นต้องสร้างเป็น method จึงพิจารณาว่าควรยุบ method นั้นกลับไปเป็นองค์ประกอบของ method ที่เกี่ยวข้องแทน
- Inline Temp เนื่องจากมีตัวแปรชั่วคราวบางตัวที่ถูกกำหนดค่าด้วยชุดคำสั่งง่าย ๆ เพียงครั้งเดียว และตัวแปรชั่วคราวนี้ยังถูกนำเข้ามาใช้ในการทำ refactoring อื่นๆ ด้วย จึงพิจารณาว่าควรยุบตัวแปรชั่วคราวนี้ แล้วแทนที่การทำงานนี้ด้วยชุดคำสั่งแทน
- Introduce A Controller
- Introduce Assertion คือ การเพิ่ม assertion เข้าไปใน code ของโปรแกรม เพื่อทดสอบสมมติฐานในเรื่องเกี่ยวกับ state ของโปรแกรม เช่นเงื่อนไขที่เป็นไปไม่ได้ ซึ่งการเพิ่ม assertion เข้าไปในส่วนที่พิจารณาว่าจำเป็นต้องมี assertion นั้นจะส่งผลให้การทำงานของโปรแกรมมีประสิทธิภาพมากขึ้น
- Introduce Business Delegate
- Introduce Explaining Variable คือ การเพิ่มตัวแปรที่มีชื่อสื่อความหมาย เพื่อเก็บผลลัพธ์ หรือส่วนของคำสั่ง เพื่อลดความซับซ้อนของคำสั่งโปรแกรม
- Introduce Foreign Method เนื่องจากมีบาง class ของ server ซึ่งกำลังใช้งานอยู่ ต้องการเพิ่ม 1 method เข้าไปใน class นั้น แต่ไม่สามารถแก้ไขโครงสร้าง class ได้ จึงทำการ refactoring โดย เพิ่ม method นั้นใน class ของฝั่ง client โดยอาศัย instance จาก class ดังกล่าวของ server โดยสร้างตอนที่เริ่มติดต่อโต้ตอบกันครั้งแรก
- Introduce Local Extension เนื่องจากมีบาง class ของ server ซึ่งกำลังใช้งานอยู่ ต้องการเพิ่ม หลาย ๆ method เข้าไปใน class นั้น แต่ไม่สามารถแก้ไขโครงสร้าง class ได้ จึงทำการ refactoring โดย เพิ่ม class ใหม่ ให้มีครบทุก method ที่ต้องการเหล่านั้น แล้วกำหนดให้เป็น sub class หรือ wrapper ของ class เดิม
- Introduce Null Object เนื่องจากมีการ วน ตรวจสอบ null value ซ้ำแล้วซ้ำอีก จึงทำการ refactoring โดยแทนที่ null value ด้วย null object
- Introduce Parameter Object เนื่องจากมีการส่งผ่าน parameter กลุ่มหนึ่งไปด้วยกันเสมอ จึงทำการ refactoring โดยส่งเป็น object แทน
- Introduce Synchronizer Token
- Localize Disparate Logic
- Merge Session Beans
- Move Business Logic to Session
- Move Class
- Move Field เนื่องจากมีบาง field ที่ (จะ) ถูกเรียกใช้โดย class อื่น มากกว่า class ตัวเอง จึงควรทำ refactoring โดยย้าย field นี้ไปไว้ใน class ที่เรียกใช้มาก ๆ ดังกล่าว
- Move Method เนื่องจากมีบาง method ที่ (จะ) ใช้ features ของ class อื่น หรือ (จะ) ถูกเรียกใช้ features จาก class อื่น มากกว่า class ตัวเอง ดังนั้นจึงควรทำ refactoring โดยย้าย method นี้ไปไว้ใน class ที่เกี่ยวข้องกับ method นี้มากที่สุด
- Parameterize Method เนื่องจากมี หลาย ๆ methods ที่ทำงานเหมือนกันต่างกันเพียงค่าที่เก็บไว้ในส่วน body ของ methods เหล่านั้น เท่านั้น ดังนั้นจึงควรทำการ refactoring โดย สร้าง method ใหม่ขึ้นมาแล้วใช้ parameter ในการเก็บค่าที่แตกต่างกันของ methods ที่ทำงานเหมือนกันแต่ค่าที่เก็บต่างกันเหล่านั้น
- Preserve Whole Object เนื่องจากมีการทำงาน ที่รับค่าหลาย ๆ ค่า จาก object แล้วส่งผ่านค่าเหล่านั้นผ่าน parameters ของ method ที่เรียกใช้ จึงควรทำ refactoring โดย ส่ง object ให้เลย
- Pull Up Constructor Body เนื่องจากมีการสร้าง constructors บน subclasses โดยที่ constructors เหล่านั้นมีการกำหนดค่าให้ข้อมูลส่วนใหญ่ของ subclasses เหล่านั้น จึงควรทำ refactoring โดยทำการ pull up constructors ของ subclasses เหล่านั้นขึ้นไปเป็น constructors ของ superclass ของมัน แล้วให้ subclasses เหล่านั้นเรียกใช้ได้
- Pull Up Field เนื่องจากมี 2 subclasses มี field ที่เหมือนกัน จึงควรทำ refactoring โดยทำการ pull up field นั้นขึ้นไปเป็น field ของ superclass ของมันเพื่อให้ทั้งสอง subclasses เรียกใช้งาน
- Pull Up Method เนื่องจากมี 2 subclasses มี method ที่เหมือนกัน จึงควรทำ refactoring โดยทำการ pull up method นั้นขึ้นไปเป็น method ของ superclass ของมันเพื่อให้ทั้งสอง subclasses เรียกใช้งาน
- Push Down Field เนื่องจากมี field ของ superclass ที่ถูกเรียกใช้งานจากบาง subclasses เท่านั้น จึงควรทำ refactoring โดยย้าย field นั้นไปไว้ใน subclasses ที่ต้องการใช้งาน
- Push Down Method เนื่องจากมี method ของ superclass ที่ถูกเรียกใช้งานจากบาง subclasses เท่านั้น จึงควรทำ refactoring โดยย้าย method นั้นไปไว้ใน subclasses ที่ต้องการใช้งาน
- Reduce Scope of Variable
- Refactor Architecture by Tiers
- Remove Assignments to Parameters เนื่องจากโปรแกรมมีำการกำหนดค่าให้กับ parameter ควรทำ refactoring โดยใช้ตัวแปรแบบชั่วคราวแทน
- Remove Control Flag เนื่องจากมีตัวแปรที่ทำหน้าที่เป็น control flag สำหรับการทำงานของชุดคำสั่งทางตรรกะ จึงควรทำ refactoring โดยใช้ break และ return แทน
- Remove Double Negative
- Remove Middle Man เนื่องจากมีการเข้าถึงข้อมูลของบาง class ที่กว่าจะได้ข้อมูลต้องเรียกใช้ผ่านหลายๆ class (เรียกว่ามีคนกลางคอยช่วย หรือก็คือ middle man) จึงควรทำ refactoring โดยทำให้เข้าถึงข้อมูลได้โดยตรง (ก็คือไม่ต้องมี middle man) ทำได้โดยทำให้ client เข้าถึงข้อมูลได้โดยตรง
- Remove Parameter เนื่องจากมีการใช้งาน parameter ในลักษณะที่จะไม่มีการใช้อีกในอนาคต จึงควร refactoring โดยเลิกใช้ parameter ดังกล่าว
- Remove Setting Method เนื่องจากมี field ที่ต้องกำหนดค่าให้ตอนสร้างครั้งแรก และห้ามเปลี่ยนแปลงแก้ไขค่าหลังจากนั้น จึงควรทำ refactoring โดยลบทุก method ที่ทำหน้าที่เปลี่ยนแปลงแก้ไขค่าของ field นี้
- Rename Method เนื่องจากมีบาง method ที่มีชื่อที่ไม่สื่อความหมาย จึงควร refactoring โดยทำการเปลี่ยนชื่อของ method นั้น
- Replace Array with Object เนื่องจากมีการใช้ array โดยที่แต่ละ elements ใน array นั้นมีการเก็บข้อมูลที่มีความหมายแตกต่างกัน จึงควร refactoring โดยการใช้ object ที่ประกอบด้วยหลาย field แทน โดยแต่ละ field ของ object แทนแต่ละ element ใน array นั่นเอง
- Replace Assignment with Initialization
- Replace Conditional with Polymorphism เนื่องจากมีโปรแกรมแบบเงื่อนไข ที่แต่ละเงื่อนไขจะทำงานต่างกันขึ้นอยู่กับ type ของ object ในเงื่อนไขนั้น ๆ จึงควรทำ refactoring โดยแทนที่โปรแกรมแบบเงื่อนไขนี้ด้วย polymorphism ซึ่งวิธีการก็คือ ทำการสร้าง subclass โดยแต่ละ subclass มี overriding method ซึ่งสร้างมาจากการดึงมาจากส่วนที่เป็นขาของแต่ละเงื่อนไขของ method เดิมใน class เดิม แล้วทำให้ method เดิมใน class เดิมนั้นเป็น abstract และให้กำหนดให้ class เดิมของ method เดิมนี้เป็น superclass ของ subclasses ใหม่ที่สร้างขึ้น
- Replace Conditional with Visitor
- Replace Constructor with Factory Method เนื่องจากต้องการทำอะไรที่มากกว่าการ construction แบบง่าย ๆ จึงควรทำ refactoring โดยแทนที่ constructor ด้วย factory method
- Replace Data Value with Object เนื่องจากมีบาง data item ที่ต้องการเพิ่มเติม data หรือ behavior เข้ามา ในตัวมัน จึงควรทำ refactoring โดยเปลี่ยน data item นั้นให้กลายเป็น object
- Replace Delegation with Inheritance เนื่องจากมีการใช้ delegation และมักจะเขียน delegation แบบง่าย ๆ เพื่อให้ interface ใช้งาน จึงควรทำ refactoring โดยเลิกใช้ delegation แต่นำ delegation ไปสร้างเป็น subclass ของ interface นั้นแทน
- Replace Error Code with Exception เนื่องจากมีการเขียนโปรแกรมที่มีการคืนค่า error code ออกมา ควรทำ refactoring โดยใช้ exception แทน
- Replace Exception with Test เนื่องจากมีบาง exception ที่่ต้องการให้ผู้เรียกตรวจสอบเงื่อนไขก่อนเป็นอันดับแรก ดังนั้นควร refactoring โดยแก้ไขโปรแกรมส่วน exception ให้ ผู้เรียก ต้องตรวจสอบก่อนเป็นอันดับแรก
- Replace Inheritance with Delegation เนื่องจากมีบาง subclass ที่ใช้เฉพาะส่วน interface ของ superclass ไม่ได้ต้องการการถ่ายทอดข้อมูล จาก superclass จึงควรทำ refactoring โดยยุบความสัมพันธ์แบบ subclass ไปสร้างเป็น field ใน superclass แล้วแก้ไข method ใน subclass เดิม (ซึ่งตอนนี้ยังคง class นี้ไว้อยู่ เพียงแต่ไม่ใช่ subclass) ให้ delegate ไปยัง superclass เดิม
- Replace Iteration with Recursion
- Replace Magic Number with Symbolic Constant เนื่องจากมีการใช้ตัวเลขเพื่อแทนความหมายเฉพาะอย่างในโปรแกรม ดังนั้นควรทำ refactoring โดยใช้ constant เพื่อใช้เก็บค่าตัวเลขเหล่านั้น โดยตั้งชื่อตัวแปรให้สื่อความหมายด้วย
- Replace Method with Method Object เนื่องจากมี long method ซึ่งใช้ local variables จึงทำใ้ห้ไม่สามารถทำ refactoring แบบ extract method ได้ ดังนั้นจึงควรใช้ object ของตัวมันเอง แทน method ดังกล่าว โดยกำหนดให้ local variables เป็น fields ของ object นี้แทน ซึ่งส่งผลให้ต่อไปก็จะไม่สามารถ decompose method นี้ไปเป็น method อื่นใน object เดียวกันได้
- Replace Nested Conditional with Guard Clauses เนื่องจากบาง method มี พฤติกรรมการทำงานตามเงื่อนไข ซึ่งไม่ชัดเจนว่า normal path ของการ execution อยู่ตรงไหน จึงควร refactoring โดยใช้ Guard Clauses แทนทุก special case เหล่านั้น
- Replace Parameter with Explicit Methods เนื่องจากบาง method มีการทำงานที่แตกต่างกันขึ้นอยู่กับค่าของ enumerated parameter จึงควร refactoring โดยสร้าง method แยกไปต่างหากสำหรับแต่ละค่าของ parameter เหล่านั้น
- Replace Parameter with Method เนื่องจากมีการเขียนโปรแกรมที่มี ตัวแปร รับค่าผลลัพธ์จาก method ใด ๆ แล้วส่งค่าผลลัพธ์ที่รับมานั้น เป็น parameter ใน method อื่นทั้ง ๆ ที่ method อื่นนั้น สามารถเรียกใช้ method ใด ๆ นั้นได้เช่นกัน ควรทำ refactoring โดย เลิกส่งผ่านค่า parameter นั้น แต่ให้ method อื่นนั้นเรียกใช้และรับค่าผลลัพธ์จาก method ใด ๆ นั้นโดยตรง
- Replace Record with Data Class เนื่องจากในสิ่งแวดล้อมแบบ traditional program นั้น หากจำเป็นต้องทำการ interface กับ record structure ควรทำ refactoring โดยใช้ dumb data object แทน record นั้น
- Replace Recursion with Iteration
- Replace Static Variable with Parameter
- Replace Subclass with Fields เนื่องจาก มีชุดของ subclasses ที่มี method ที่ inherit มาจาก superclass เหมือน ๆ กัน แต่ที่แยกเป็น subclasses ที่แตกต่างกัน เพราะต้องการค่าที่คืนกลับมายังผู้เรียกต่างกันเท่านั้น จึงควรทำ refactoring โดยยุบ subclasses เหล่านั้น และนำไปสร้างเป็น fields ใน superclass เพื่อให้ method ต้นฉบับใน superclass เรียกใช้แทน
- Replace Temp with Query เนื่องจากมีการใช้ตัวแปรชั่วคราวในการเก็บผลลัพธ์ของ expression จึงควรทำ refactoring โดย สร้าง method ใหม่ แ้ล้วทำการ extract expression นั้นไปไว้ใน method ใหม่ดังกล่าว พร้อมทั้งแทนที่การอ้างถึงตัวแปรชั่วคราวดังกล่าวด้วย expression ใน method ใหม่ ซึ่ง method ใหม่นี้สามารถถูกนำไปใช้ใน method อื่น ๆ ต่อไปได้
- Replace Type Code with Class เนื่องจากบาง class ประกอบด้่วย numeric type code เพราะไม่ต้องการใ้ห้กระทบพฤติกรรมการทำงานของโปรแกรม จึงควรทำ refactoring โดยการสร้าง class ใหม่ แล้วแทนที่ numeric type code นั้นด้วย class ใหม่ที่สร้างขึ้น
- Replace Type Code with State/Strategy เนื่องจากมีบาง type code ที่มีผลกระทบกับพฤติกรรมการทำงานของ class แต่ไม่สามารถสร้าง subclasses ได้ กรณีนี้ควรทำ refactoring โดยแทนที่ type code นั้นด้วย state object
- Replace Type Code with Subclasses เนื่องจากมีบาง type code ซึ่งเปลี่ยนรูปไม่ได้ และมีผลกระทบกับพฤติกรรมการทำงานของ class กรณีนี้ควรทำ refactoring โดยแทนที่ type code นั้นด้วย subclasses
- Reverse Conditional
- Self Encapsulate Field เนื่องจากมีการเข้าถึงบาง field ได้โดยตรง แต่การ coupling ไปยัง field นั้นค่อนข้างงุ่มง่าม ดังนั้นควรทำ refactoring โดยสร้าง getting และ setting methods สำหรับ field นั้น เพื่อใช้ในการเข้าถึง field นั้นเพียงอย่างเดียว
- Separate Data Access Code
- Separate Query from Modifier เนื่องจากมีบาง method ที่ถึงแม้จะมีการคืนค่าออกมา แต่ก็ยังคงเปลี่ยนแปลง state ของ object ได้ จึงควรทำ refactoring โดยสร้าง 2 methods ใหม่ขึ้นมา โดย method แรกเพื่องาน query ส่วนอีก method มีไว้เพื่องาน modification
- Split Loop
- Split Temporary Variable เนื่องจากมีการใช้ตัวแปรชั่วคราว และกำหนดค่าให้ตัวแปรชั่วคราวนั้นมากกว่าหนึ่งครั้ง แต่ไม่ใช่ตัวแปรแบบวนรอบและไม่ใช่ตัวแปรสำหรับเก็บค่าสะสม ดังนั้นควรทำ refactoring โดยแยกตัววแปรชั่วคราวนั้นออกมาให้เพื่อให้มีหนึ่งตัวแปรต่อการกำหนดค่าหนึ่งครั้ง
- Substitute Algorithm เนื่องจากต้องการแทน algorithm ด้วยสิ่งที่ชัดเจนขึ้น ดังนั้นควร refactoring โดยแทนที่ส่วน body ของ method ด้วย algorithm ใหม่
- Use a Connection Pool
- Wrap entities with session
ผมเสนอว่าลองมาจัดกลุ่มสักหน่อยดีไหมครับ เช่นกลุ่มของ refactoring ที่เกี่ยวกับการโปรแกรมแบบทั่ว ๆ ไป การ refactoring เกี่ยวกับการโปรแกรมในระดับ enterprise อะไรประมาณนี้นะ่ครับ
ตอบลบ