Reverse Engineering of Design Patterns from Java Source Code - PowerPoint PPT Presentation

1 / 28
About This Presentation
Title:

Reverse Engineering of Design Patterns from Java Source Code

Description:

Reverse Engineering of Design Patterns from Java Source Code UC DAVIS Nija Shi shini_at_cs.ucdavis.edu Ron Olsson olsson_at_cs.ucdavis.edu Outline Design patterns vs ... – PowerPoint PPT presentation

Number of Views:111
Avg rating:3.0/5.0
Slides: 29
Provided by: Nij98
Category:

less

Transcript and Presenter's Notes

Title: Reverse Engineering of Design Patterns from Java Source Code


1
Reverse Engineering ofDesign Patterns from Java
Source Code
UC DAVIS
  • Nija Shi
  • shini_at_cs.ucdavis.edu
  • Ron Olsson
  • olsson_at_cs.ucdavis.edu

2
Outline
  • Design patterns vs. reverse engineering
  • Reclassification of design patterns
  • Pattern detection techniques
  • PINOT
  • Ongoing and future work

3
Design Patterns
  • A design pattern offers guidelines on when,
    how, and why an implementation can be created to
    solve a general problem in a particular context.
  • -- Design Patterns Elements of Reusable
    Object-Oriented Software
  • Gang of Four (GoF)
  • A few well-known uses
  • Singleton Java AWTs (GUI builder) Toolkit class
  • Proxy CORBAs (middleware) proxy and real
    objects
  • Chain of Responsibility Tomcats (application
    server) request handlers

4
Reverse Engineering of Design Patterns
Singleton
Composite
layoutMgr 1
AbstractFactory
1
Strategy
Bridge
5
Representative Current Approaches
Tools Language Techniques Case Study Patterns Targeted
SPOOL C Database query ET Template Method, Factory Method, Bridge
DP C Database query DTK Composite, Flyweight, Class Adapter
Vokac et al. C Database query SuperOffice CRM Singleton, Template Method, Observer, Decorator
Antoniol et al. C Software metric Leda, libg, socket, galib, groff, mec Adapter, Bridge
SPQR C Formal semantic test programs Decorator
Balanyi et al. C XML matching Jikes, Leda, Star Office Calc, Writer Builder, Factory Method, Prototype, Bridge, Proxy, Strategy, Template Method
PTIDEJ Java Constraint Solver Java.awt., Java.net. Composite, Facade
FUJABA Java Fuzzy logic and Dynamic analysis Java AWT Bridge, Strategy, Composite
WoP Scanner Java AST query AWT, Swing, JDBC API, etc. Abstract Factory
HEDGEHOG Java Formal Semantic PatternBox, Java 1.1, 1.2 Most GoF patterns (discussed later)
Heuzeroth et al. Java Dynamic analysis Java Swing Observer, Mediator, CoR, Visitor
KT SmallTalk Dynamic analysis KT Composite, Visitor, Template Method
MAISA UML UML matching Nokia DX200 Switching System Abstract Factory
6
Current Approaches
  • Limitations
  • Misinterpretation of pattern definitions
  • Limited detection scope on implementation
    variants
  • Can be grouped as follows
  • Targeting structural aspects
  • Analyze class/method declarations
  • Analyze inter-class relationships (e.g., whether
    one class extends another)
  • Targeting behavioral aspects
  • Analyze code semantics (e.g., whether a code
    segment is single entry)

7
Targeting Structural Aspects
  • Method
  • Extract structural relationships (inter-class
    analysis)
  • For a pattern, check for certain structural
    properties
  • Drawback
  • Relies only on structural relationships, which
    are not the only distinction between patterns

8
Targeting Behavioral Aspects
  • Method
  • Narrow down search space
  • using inter-class relationships
  • Verify behavior in method bodies
  • Dynamic analysis
  • Machine learning
  • Static program analysis

9
Targeting Behavioral Aspects
  • Drawback
  • Dynamic analysis
  • Requires good data coverage
  • Verifies program behavior but does not verify the
    intent
  • Complicates the task for detecting patterns that
    involve concurrency
  • Machine learning
  • Most patterns have concrete definitions, thus
    does not solve the fundamental problem.

10
A Motivating Example
public class Singleton private static
Singleton instance private Singleton()
public static Singleton getInstance()
  • Detecting the
  • Singleton Pattern
  • As detected by FUJABA
  • Common search criteria
  • private Singleton()
  • private static Singleton instance
  • public static Singleton getInstance()
  • Problem
  • No behavioral analysis on getInstance()
  • Solution?

if (instance NULL) instance new
Singleton() return instance
instance new Singleton() return instance
return new Singleton()

11
GoF Patterns Reclassified
12
Language-provided Patterns
  • Patterns provided in the language or library
  • The Iterator Pattern
  • Provides a way to access the elements of an
    aggregate object sequentially without exposing
    its underlying representation GoF
  • In Java
  • Enumeration since Java 1.0
  • Iterator since Java.1.2
  • The for-each loop since Java 1.5
  • The Prototype Pattern
  • Specify the kinds of objects to create using a
    prototypical instance, and create new objects
    based on this prototype
  • In Java
  • The clone() method in java.lang.Object
  • Pattern Detection
  • Recognizing variants in legacy code

13
Structure-driven Patterns
  • Patterns that are driven by software
    architecture.
  • Can be identified by inter-class relationships
  • The Template Method, Composite, Decorator,
    Bridge, Adapter, Proxy, Facade patterns
  • Inter-class Relationships
  • Accessibility
  • Declaration
  • Inheritance
  • Delegation
  • Aggregation
  • Method invocation

14
Behavior-driven Patterns
  • Patterns that are driven by system behavior.
  • Can be detected using inter-class and program
    analyses.
  • The Singleton, Abstract Factory, Factory Method,
    Flyweight, CoR, Visitor, Observer, Mediator,
    Strategy, and State patterns.
  • Program analysis techniques
  • Program slicing
  • Data-flow analysis
  • Call trace analysis

15
Domain-specific Patterns
  • Patterns applied in a domain-specific context
  • The Interpreter Pattern
  • Given a language, define a representation for
    its grammar along with an interpreter that uses
    the representation to interpret sentences in the
    language GoF
  • Commonly based on the Composite and Visitor
    patterns
  • The Command Pattern
  • Encapsulate a request as an object, thereby
    letting you parameterize clients with different
    requests, queue or log requests, and support
    undoable operations GoF
  • A use of combining the Bridge and Composite
    patterns to separate user interface and actual
    command execution. The Memento pattern is also
    used to store a history of executed commands
  • Pattern Detection
  • Requires domain-specific knowledge

16
Generic Concepts
  • Patterns that are generic concepts
  • The Builder Pattern
  • Separate the construction of a complex object
    from its representation so that the same
    construction can create different representation
    GoF
  • System bootstrapping pattern, object creation is
    not necessary
  • The Memento Pattern
  • Without violating encapsulation, capture and
    externalize an objects internal state so that
    the object can be restored to this state later
    GoF
  • Implementation of memo pool and representation of
    states are not specifically defined.
  • Pattern detection
  • Lack implementation trace

17
Recognizing the Singleton Pattern
  • Structural aspect
  • private Singleton()
  • private static Singleton instance
  • public static Singleton getInstance()
  • Behavioral aspect
  • Analyze the behavior in getInstance()
  • Check if lazy-instantiation is implemented
  • Check if instance is returned
  • Slice the method body for instance and analyze
    the sliced program

recall
18
Recognizing the Singleton Pattern
public class SingleSpoon private
SingleSpoon() private static SingleSpoon
theSpoon public static SingleSpoon
getTheSpoon() if (theSpoon null)
theSpoon new SingleSpoon() return
theSpoon
19
Pattern INference and recOvery Tool
  • PINOT
  • A fully automated pattern detection tool
  • Designed to be faster and more accurate
  • Detects structural- and behavioral-driven
    patterns
  • How PINOT works

Pattern Instances
JAVA
Text
PINOT
Source Code
Pattern Instances
view
XMI
editors
U
M
L
20
Implementation Alternatives
  • Program analysis tools
  • Extract basic information of the source code
  • Class, method, and variable declarations
  • Class inheritance
  • Method invocations, call trace
  • Variable refers-to and refers-by relationships
  • Parsers
  • Extract the abstract syntax tree (AST)
  • Compilers
  • Extract the AST and provide related symbol tables
    and built-in functions operating on the AST

21
Implementation Overview
  • A modification of Jikes (open source C Java
    compiler)
  • Analysis using Jikes abstract syntax tree (AST)
    and symbol tables
  • Identifying Structure-driven patterns
  • Considers Java language constructs
  • Considers commonly used Java utility classes
    java.util.Collection and java.util.Iterator
  • Identifying Behavior-driven patterns
  • Applies data-flow analysis, inter-procedural
    analysis, alias analysis
  • PINOT considers related patterns
  • Speed up the process of pattern recognition
  • E.g., Strategy and State Patterns, CoR and
    Decorator, etc.

22
PINOT HEDGEHOG FUJABA
Creational Abstract Factory Yes Yes No
Creational Builder
Creational Factory Method Yes Yes No
Creational Prototype No
Creational Singleton Yes Yes Yes
Structural Adapter Yes Yes No
Structural Bridge Yes Yes Yes
Structural Composite Yes Yes No
Structural Decorator Yes Yes No
Structural Facade Yes Yes
Structural Flyweight Yes Yes No
Structural Proxy Yes Yes
Behavioral Chain of Responsibility Yes No
Behavioral Command
Behavioral Interpreter
Behavioral Iterator Yes No
Behavioral Mediator Yes No
Behavioral Memento No
Behavioral Observer Yes Yes No
Behavioral State Yes No
Behavioral Strategy Yes Yes Yes
Behavioral Template Method Yes Yes Yes
Behavioral Visitor Yes Yes
Yes. The tool provides recognition for the
pattern and correctly identifies it.
No. The tool provides recognition for the
pattern but fails to identify it.
Blank. The tool does not provide recognition for
the pattern.
23
Benchmarks
  • Java AWT (GUI toolkit)
  • javac (Sun Java Compiler)
  • JHotDraw (GUI framework)
  • Apache Ant (Build tool)
  • Swing (Java Swing library)
  • ArgoUML (UML editor tool)

24
PINOT Results
  • PINOT works well in terms of accuracy it
    recognizes many pattern instances in the
    benchmarks.
  • Like other pattern detection tools, PINOT is not
    perfect
  • False positives
  • Prototype vs. Factory Method
  • PINOT does not detect Prototype pattern
  • Prototype pattern involves object creation
  • PINOT identifies implementation of clone methods
    as factory methods
  • False Negatives
  • User-defined data structures
  • Container structures are commonly used with
    Observer, Mediator, Composite, Chain of
    Responsibility patterns, etc.

25
Pattern Interpretation
  • Flyweight vs. Immutable
  • Immutable classes are sharable singletons
  • Mediator vs. Facade
  • Colleagues of participating in the Mediator
    pattern can have different types
  • A mediator class becomes a facade against an
    individual colleague class

26
PINOT Results
27
Timing Results
  • A comparison
  • PtideJ
  • 2-3 hours analyzing JHotDraw
  • Platform AMD Athlon 2GHz 64b processor
  • Fujaba
  • 22 minutes analyzing Java AWT
  • Platform Pentium III 933MHz processor
  • with 1G of memory

28
Ongoing and Future Work
  • Investigate other domain-specific patterns
  • High performance computing (HPC) patterns
  • Real-time patterns
  • Extend usability of PINOT
  • Formalize pattern definitions
  • Visualizing detection results

29
PINOT Eclipse
30
Conclusion
  • Reverse engineering of design patterns
  • Reclassifying the GoF patterns for
    reverse-engineering
  • PINOT a faster and more accurate pattern
    detection tool
  • Ongoing and future work
  • More information on our website
    http//www.cs.ucdavis.edu/shini/research/pinot
Write a Comment
User Comments (0)
About PowerShow.com