Java Reflection Research Articles

Client-server application framework based on an object-oriented network model

The relationship between the business layer and the underlying data access layers is considered. The disadvantages of the traditional approach based on the relational database and the data access layer (DAO/ORM) are analyzed. A document-oriented database with built above it an object-oriented network model of data presentation is proposed. The integration with the business layer, automatic assembly of business objects using Java reflection without additional specifications, polymorphic storage and transfer of business entities in collections of the document-oriented database is supported.

Is Your Android App Insecure? Patching Security Functions With Dynamic Policy Based on a Java Reflection Technique

With the popularization of smart devices, companies are adopting bring-your-own-device or mobile office policies that utilize personal smart devices for work. However, as work data are stored on individual smart devices, critical security threats are emerging, such as the leakage of confidential documents. Enterprises want to address this issue by adapting enterprise mobility management (EMM) solutions. Appwrapping is among the core technologies in EMM solutions, enabling security function insertion or misused code patching without the original application (app) source code. Studies on permission control, misused code patching, security function insertion based on static policies, etc., have been conducted, but there are limitations such as poor user convenience and overhead. In this paper, we propose an AppWrapper toolkit to support dynamic polices. Basically it can insert security function execution code into apps by using appwrapping technology without the original source code. This code uses Java reflection to invoke security functions dynamically based on preset policies. Accordingly, after the initial appwrapping, the policy can be changed easily. In addition, even when multiple security functions are required, Java reflection can invoke multiple security functions dynamically and simultaneously without conflicting with the existing code. The AppWrapper toolkit also provides a log function to check in real time where the security function is needed. Hence, the policy-setting administrator can check the log in real time and implement the security function where needed. Our experimental results show that this technique improves significantly the efficiency, effectiveness, and convenience of adding security function execution code.

Understanding and Analyzing Java Reflection

Java reflection has been widely used in a variety of applications and frameworks. It allows a software system to inspect and change the behaviour of its classes, interfaces, methods, and fields at runtime, enabling the software to adapt to dynamically changing runtime environments. However, this dynamic language feature imposes significant challenges to static analysis, because the behaviour of reflection-rich software is logically complex and statically hard to predict. As a result, existing static analysis tools either ignore reflection or handle it partially, resulting in missed, important behaviours, i.e., unsound results. Therefore, improving or even achieving soundness in static reflection analysis—an analysis that infers statically the behaviour of reflective code—will provide significant benefits to many analysis clients, such as bug detectors, security analyzers, and program verifiers. In this article, we provide a comprehensive understanding of Java reflection through examining its underlying concept, API, and real-world usage, and, building on this, we introduce a new static approach to resolving Java reflection effectively in practice. We have implemented our reflection analysis in an open-source tool, called S OLAR , and evaluated its effectiveness extensively with large Java programs and libraries. Our experimental results demonstrate that S OLAR is able to (1) resolve reflection more soundly than the state-of-the-art reflection analyses; (2) automatically and accurately identify the parts of the program where reflection is resolved unsoundly or imprecisely; and (3) guide users to iteratively refine the analysis results by using lightweight annotations until their specific requirements are satisfied.

Dypermin: Dynamic permission mining framework for android platform

The Android architecture introduces to the application layer a permission based access control model for restricting access to sensitive phone resources. In this model the access to Application Programming Interfaces (APIs) is protected through permissions defined by the Android OS. The developers in order to utilize protected API methods must declare, in the application’s manifest, the appropriate permissions. The “relation” between framework method and a permission can be found through Android’s documentation. However, not only documentation may accidentally lack information but also Android features undocumented and hidden API methods. Undoubtedly a major challenge for researchers today, is the accurate identification of API methods and permissions pairs, which compose the permission map for the Android framework.This paper introduces Dypermin; a transparent framework for compiling the Android permission map without requiring any modification to the underlying operating system. To achieve that, Dypermin capitalizes on intrinsic properties of the Android framework that is security exceptions during runtime and the availability of any protected API method through the Android framework, as well as on the advantages of Java reflection mechanism. Dypermin, in contrast to other related methods, validates itself as it relies on runtime information, meaning that it does not generate false positive map entries. Dypermin has been evaluated on different Android versions. The results have been compared with the respective results of other proposed methods in order to demonstrate Dypermin’s efficacy for compiling the Android permission map for any given version.

A Framework for Calculating the Failure Probability of Natural Gas Pipeline

Reliability based design and assessment (RBDA) technique is a developing direction of natural gas pipeline design method. In this paper, a framework for calculating the failure probability of natural gas pipeline is proposed. First, Java reflection mechanism is used in the management of the limit state functions, which enables the separation of the limit state algorithms and the calculations of the failure probability. Under this framework, more newly developed equations can be add into the library of the software readily. Second, a Monte Carlo reliability analysis algorithm capable of incorporating the basic input parameters and limit state functions is used to calculate failure probability of pipelines. Third, a post data processing algorithm is used to improve the efficiency. Finally, an example on natural gas pipeline is presented to illustrate the availability and effectiveness of the software. Experimental results indicate the ability of the proposed framework for pipeline quality control.

Discovering the Java reflection API with an iterated prisoner's dilemma

The Iterated Prisoner's Dilemma (IPD) is an abstract game that has been used to model the emergence of cooperative behavior among rational individuals motivated purely by self-interest. Widespread ...

Obsidian: Pattern-Based Unit Test Implementations

There exist many automated unit test-generator tools for Java with the primary task of generating test cases, comprised of inputs and a corresponding oracle, each of which is explicitly paired with a specific supporting test implementation. The authors posit that this explicit pairing, or conflating, of test implementation with test case is unnecessary and counter-productive. The authors address this problem by separating the conflated concerns into two distinct tasks: 1) instantiating test implementations and 2) instantiating test cases. This paper focuses on automating the first task in support of the second with the goal of freeing the test engineer to concentrate on test case instantiation. The authors present a new open-source test-preparation tool Obsidian that produces robust, comprehensive, and maintainable unit test implementations. Obsidian, built on the JUnit framework, uses a set of context patterns and associated algorithms combined with information from the Java Reflection API to generate these unit test implementations from Java byte code. These context patterns guide Obsidian to prepare test implementations that guarantee compilation, support exception handling, enable multiple test cases when required, and provide a suitable location for assertions about the test case outcome(s). Obsidian supports regression testing and test-driven development through its novel audits of the testing process.

The Static Analysis of the Uniqueness of Polymorphism

The existence of the polymorphism brings many changes on the executable paths of the object-oriented program, which makes it difficult to test the internal communication of the system and the interaction between the objects. This paper analyzes the structure feature of the Java program and builds an inheritance tree using the technique of reflection in Java, which guarantees the accuracy of the analysis data. This paper proposes an algorithm to determine the uniqueness based on the full analysis of the Java polymorphic calling states and the Liskov substitution principle. And the algorithm uses the asynchronous mode of high concurrency to increase the efficiency. The result shows the algorithm can determine the uniqueness of polymorphism efficiently and accurately. It can play an important role in the Java program comprehension and the system maintenance.

Visual reflection library: a framework for declarative GUI programming on the Java platform

The automated mapping of program functionality to intuitive user interfaces is a highly challenging task. Nevertheless it is a promising way to significantly improve software quality by simplifying the development process. This paper describes a method for a declarative and fully automated creation of graphical user interfaces from Java objects, i.e. the information accessible via the Java Reflection API. For this purpose we created the Visual Reflection Library (VRL). VRL interfaces are able to represent complex workflows and allow for a certain degree of visual programming. We start by describing an application: the development of an interactive user interface for the simulation system UG. By shortly discussing the requirements for such an interface, we will explain the reasons for creating VRL and the benefits we gained from it. After that we give an overview of our methods and show several applications. We end by summarizing our results and giving a future outlook.

Reflection Support: Java Reflection Made Easy

Large software projects often require the ability to load and manage new code assets that were not originally available during system compilation. Moreover, testing tools need to inspect and run code components regardless of their structures. Reflection in Java supports these tasks by providing programmers with facilities to dynamically create objects, invoke methods, access fields, and perform code introspection at runtime. These capabilities come at the cost of reduced readability and writeability, since code written using Java's reflection classes is clunky, bulky and unintuitive. Common tasks such as object creation, method invocation, and field manipulation need to be decomposed into multiple steps that require try-catch blocks to guard against checked exceptions. Type casts and explicit use of class types as parameters make development and maintenance of code difficult, time consuming and error prone. In this paper, we discuss the diffi- culties of using reflection in Java. We also present an open-source library called ReflectionSupport that addresses these problems and makes reflection in Java easier to use. ReflectionSupport provides static helper methods that offer the same reflective capabilities but that encapsulate the overhead of coding with reflection. This paper focuses on improving the us- ability of Java reflection by presenting an API that allows programmers to obtain the benefits of reflection without the hassle.

Goal Driven Architecture Development using LEAP

Methods for goal driven system engineering exist and propose a number of categories of goals including behavioural, formal, informal and non-functional. This article goes further than existing goal driven approaches by linking goals directly to the semantics of an architectural modelling language called LEAP with an operational semantics. The behavioural goals are expressed using a Linear Temporal Logic and the non-functional goals are expressed as functions over meta-properties of the model. The meta-properties are supported using an encoding represented using Java reflection. The article describes the LEAP approach using a simple case study written in the LEAP language supported by the LEAP toolset.

Morphing

We present MorphJ: a language for specifying general classes whose members are produced by iterating over members of other classes. We call this technique “class morphing” or just “morphing.” Morphing extends the notion of genericity so that not only types of methods and fields, but also the structure of a class can vary according to type variables. This adds a disciplined form of metaprogramming to mainstream languages and allows expressing common programming patterns in a highly generic way that is otherwise not supported by conventional techniques. For instance, morphing lets us write generic proxies (i.e., classes that can be parameterized with another class and export the same public methods as that class); default implementations (e.g., a generic do-nothing type, configurable for any interface); semantic extensions (e.g., specialized behavior for methods that declare a certain annotation); and more. MorphJ's hallmark feature is that, despite its emphasis on generality, it allows modular type-checking: a MorphJ class can be checked independently of its uses. Thus, the possibility of supplying a type parameter that will lead to invalid code is detected early, an invaluable feature for highly general components that will be statically instantiated by other programmers. We demonstrate the benefits of morphing with several examples, including a MorphJ reimplementation of DSTM2, a software transactional memory library which reduces 1,484 lines of Java reflection and bytecode engineering library calls to just 586 lines of MorphJ code.

Research and implementation of embedded Java reflection mechanism

Java reflection is an important technology,which can improve software system flexibility and is a key feature for Java to be regarded as dynamic language.Though CLDC specification does not support reflection,it is still required in embedded area based on Java technology.Sun Microsystems released a reference implementation of embedded Java technology according to CLDC specification.The authors described the reflection design principle in detail by analyzing related data structure and mechanism of KVM,as well as it presented a method to extend reflection for KVM.The method is proved feasible by test.

High Performance Approach for Server Side SOAP Processing

Based on XML, Web services inherit not only the advantages of XML, but its relatively poor performance, which makes it a poor choice for many high-performance applications. In this paper, we propose a new approach to improve Web services performance. Focusing on avoiding traditional XML parsing and Java reflection at runtime, this paper develops a service-specific SOAP Processor to accelerate execution. Moreover, SOAP Processor embeds several cache implementations and uses a novel adaptive cache mechanism, which can choose an optimized cache implementation dynamically in the runtime. Through our experiments in this paper, we observed that our approach can achieve a huge performance gain by incorporating the SOAP Processor into the SOAP engine.

Expressive and safe static reflection with MorphJ

Recently, language extensions have been proposed for Java and C# to support pattern-based reflective declaration . These extensions introduce a disciplined form of meta-programming and aspect-oriented programming to mainstream languages: They allow members of a class (i.e., fields and methods) to be declared by statically iterating over and pattern-matching on members of other classes. Such techniques, however, have been unable to safely express simple, but common, idioms such as declaring getter and setter methods for fields. In this paper, we present a mechanism that addresses the lack of expressiveness in past work without sacrificing safety. Our technique is based on the idea of nested patterns that elaborate the outer-most pattern with blocking or enabling conditions. We implemented this mechanism in a language, MorphJ. We demonstrate the expressiveness of MorphJ with real-world applications. In particular, the MorphJ reimplementation of DSTM2, a software transactional memory library, reduces 1,107 lines of Java reflection and bytecode engineering library calls to just 374 lines of MorphJ code. At the same time, the MorphJ solution is both high level and safer, as MorphJ can separately type check generic classes and catch errors early. We present and formalize the MorphJ type system, and offer a type-checking algorithm.

Research on dynamic update transaction for Java classes

Dynamic software updating is critical for many systems that must provide continuous service. In addition, the Java language is gaining increasing popularity in developing distributed systems. Most previous works on updating are concerned with safely updating one class every time. It has many limitations on updating classes, such as not allowing deleting methods invoked in other classes. In this paper, the update transaction is purposed to dynamically update the class set, and some of its properties are discussed, such as atomicity, consistency, isolation, and durability (ACID). Then the property of type-safety is proven formally. In order to update without changing the Java Virtual Machine (JVM) and the Java programming language, this paper proposes a new implementation method. The method makes use of the Java class loading mechanism and reflection mechanism. We also present how to design an updatable Java program and a Java updating program. At the end of the paper, an experiment is made for analysis.

The Yoix® scripting language: a different way of writing Java™ applications

AbstractOur work led us to write a full‐featured, reliable and extensible scripting language implemented in Java and providing access to many Java capabilities. The result provides a mechanism for fast and efficient development, deployment and maintenance of client/server applications. The Yoix interpreter does not rely on Java reflection classes to access Java capabilities, but rather uses programmatic methods. This approach allowed us to deliver the complex aspects of Java functionality more simply and succinctly at the Yoix level as well as achieve consistent behavior and portability across platforms. We also included many practical functions and capabilities for application development. Indistinguishable from Java applications to end‐users, a Yoix application's interpreted nature allows scripts to be downloaded from a Web server and executed as needed by the application. This framework has been used successfully for mission critical applications within AT&T. The interpreter, its source, documentation, a completely functional application template and a large set of examples are freely available for download under open source licensing from the AT&T Labs—Research Web site at http://www.research.att.com/sw/tools/yoix/ or its alias http://www.yoix.org/. Yoix is a registered trademark of AT&T, Inc. Java is a trademark of Sun Microsystems, Inc. Copyright © 2006 John Wiley & Sons, Ltd.

A Design for Type-Directed Programming in Java

Type-directed programming is an important and widely used paradigm in the design of software. With this form of programming, an application may analyze type information to determine its behavior. By analyzing the structure of data, many operations, such as serialization, cloning, adaptors and iterators may be defined once, for all types of data. That way, as the program evolves, these operations need not be updated—they will automatically adapt to new data forms. Otherwise, each of these operations must be individually redefined for each type of data, forcing programmers to revisit the same program logic many times during a program's lifetime.The Java language supports type directed programming with the instanceof operator and the Java Reflection API. These mechanisms allow Java programs to depend on the name and structure of the run-time classes of objects. However, the Java mechanisms for type-directed programming are difficult to use. They also do not integrate well with generics, an important new feature of the Java language.In this paper, we describe the design of several expressive new mechanisms for type-directed programming in Java, and show that these mechanisms are sound when included in a language similar to Featherweight Java. Basically, these new mechanisms pattern-match the name and structure of the type parameters of generic code, instead of the run-time classes of objects. Therefore, they naturally integrate with generics and provide strong guarantees about program correctness. As these mechanisms are based on pattern matching, they naturally and succinctly express many operations that depend on type information. Finally, they provide programmers with some degree of protection for their abstractions. Whereas instanceof and reflection can determine the exact run-time type of an object, our mechanisms allow any supertype to be supplied for analysis, hiding its precise structure.

A plug and play approach for developing environmental models

The need for better collaboration among scientists and different existing environmental models makes it necessary to find efficient ways of using and reusing functionalities or services provided by third parties. New advances in software engineering can be successfully used to develop environmental models that use an enabling architecture for a “plug and play” approach. In this study, the Kraalingen crop simulation model was used to demonstrate the concept and feasibility of the “plug and play” architecture for crop simulation models. Strategy and AbstractFactory design patterns are used as the basis for the “plug and play” approach. In addition to design patterns, Java's reflection was used to dynamically instantiate the appropriate Strategy instance. This paper focuses only on the issues dealing with design and implementation of the “plug and play” architecture. This architecture was successfully tested using several components providing polymorphic behavior in the Kraalingen model. Components for obtaining weather data from different sources were plugged into the system without requiring changes to the code. This approach creates the necessary technical environment for scientists to focus on what they know the best, save time and effort and subsequently, increase the cross-disciplinary interaction for creating better models.

A reflective implementation of Java multi-methods

In Java, method implementations are chosen at runtime by late-binding with respect to the runtime class of just the receiver argument. However, in order to simplify many programming designs, late-binding with respect to the dynamic type of all arguments is sometimes desirable. This behavior, usually provided by multimethods, is known as multipolymorphism. This work presents a new multimethod implementation based on the standard Java reflection mechanism. Provided as a package, it does not require any language extension or any virtual machine modification. The design issues of this reflective implementation are presented together with a new and simple multimethod dispatch algorithm that efficiently supports class loading at runtime. This implementation provides a practicable and fully portable multimethod solution.