Article transferred from http://blog.9cbs.net/kyokosaika/archive/2004/12/01/199935.aspx Thank you! The concept of reflective mechanism in Java, reflection concept: The concept of reflection is first proposed by Smith in 1982, mainly means that the program can access, detect, and modify its own status or behavior. This concept is raised soon triggered research on application reflexibility in computer science. It is first adopted by the design area of the program language and achieves grades in LISP and object-oriented. Among them, Lead / Lead , OpenC , Metaxa and Openjava are based on reflex mechanisms. Recently, reflective mechanisms are also applied to window systems, operating systems, and file systems. Reflection itself is not a new concept, which may make us in the optical reflection concept, although computer science gives the new meaning of reflection concept, but from the phenomenon, they do have some communication, these Help our understanding. In the field of computer science, reflection refers to a class of applications that are self-describing and self-control. That is, this type of application implements a self-representation and monitoring of its own behavior by adopting a mechanism, and can adjust or modify the status of the behavior described in the application according to the status and results of their own behavior. Related semantics. It can be seen that the reflection of the computer science field is not single referred to the reflection itself compared to the general reflection concept, and the measures taken to the reflection result. All systems (ie, reflection systems) that use reflex mechanisms want to make the system's implementation more open. It can be said that the system that realizes the reflective mechanism has openness, but an open system does not necessarily adopt a reflective mechanism, and the openness is the necessary conditions for the reflective system. In general, the reflection system must meet the cause connection (Causally-Connected) in addition to the open condition. The so-called reason connection refers to the changes that the change in the reflective system can immediately reflect the actual state and behavior of the underlying layer of the system, and vice versa. Openness and reasons are two basic elements of the reflective system. 13700863760 Java, reflection is a powerful tool. It enables you to create flexible code that can be assembled at runtime without having to link between components. Reflection allows us to write to the internal information of the class loaded into the JVM when writing and execution, instead of the selected class collaboration in the source code. This makes reflections become the main tool for building flexible applications. However, it is important to note that if improper use, the reflection costs are high. Second, the class reflection in Java: Reflection is one of the features of the Java program development language, which allows the Java program in the run to check themselves, or "self-trial", and can directly operate the internal properties of the program. This capability of Java may not be used in practical applications, but there is no such feature in other programming languages. For example, there is no way to get the function definition related information in the program in PASCAL, C, C . 1. Detection class: 1.1 Reflection work mechanism Considering the following simple example, let's see how the reflection works.
Import java.lang.reflect. *; public class dumpmethods {public static void main (string args []) {try {class c = class.Forname (args [0]); method m [] = c.getDeclaredMetHods (); For (int i = 0; i The following is a set of reflection calls for finding constructor: l Constructor getConstructor (class [] params) - Get public constructors using special parameter types, l Constructor [] getConstructors () - All public constructs for class Function l Constructor getDeclaredConstructor (class [] params) - Get all constructor (unrelated to access level) using a specific parameter type, L Constructor [] getDeclaredConstructors () - Get all constructor (unrelated to access level) The Class reflection call for field information is different from those calls used to access constructors, and the field name is used in the parameter type array: l Field getfield (String name) - Get a named public field L Field [] getfields () - - Get all common fields of the class L Field getDeclaredfield (String Name) - Get Named Fields of Name Declaration L Field [] getDeclaredfields () - All fields for obtaining classes Declarations for getting the method information function: l method getMethod (String Name, class [] params - use specific parameter types to get naming public methods l method [] getMethods () - Get all public methods of category l method getDeclaredMethod (String name, class [] params) - use Close-up parameter type, get the method of naming the class declaration L method [] getDeclaredMethods () - Get all methods of getting class declaration 1.3 Start using Reflection: Class for Reflection, such as Method, can be in the java.lang.relfect package turn up. When using these classes, you must follow three steps: The first step is to get the java.lang.class object you want to operate. In the Java program in the run, the classes and interfaces are described with the java.lang.class class. Below is one of the methods of obtaining a Class object: Class C = Class.Forname ("java.lang.string"); this statement gets a class object for a String class. There is another method, as follows: Class C = int.class; or class c = integer.Type; they obtain basic type of class information. The latter method is accessed in the basic type of package class (such as Integer) pre-defined Type fields. The second step is to call a method such as getDeclaredMethods to obtain a list of all methods defined in this class. Once this information is taken, you can perform the third step - use the Reflection API to operate this information, as this code: Class C = Class.Forname ("java.lang.string"); method m [] = C .GetDeclaredMethods (); System.out.println (M [0] .tostring ()); it will print out the prototype of the first method defined in the String in text. 2. Treatment object: If you want to make a development tool like Debugger, you must find FileD Values, the following is three steps: a. Create a Class object B. Create a Field object with GetField C. Call Field.Getxxx (Object ) Method (XXX is int, float, etc., if it is omitted; object is an instance). For example: import java.lang.reflect. *; Import java.awt. *; Class sampleget {public static void main (String " ] args) {Rectangle r = new Rectangle (100, 325); printHeight (r);} static void printHeight (Rectangle r) {Field heightField; Integer heightValue; Class c = r.getClass (); try {heightField = c. Getfield ("Height"); HeightValue = (Integer) Heightfield.get (R); System.out.Println ("Height:" HeightValue.toString ());} catch (nosuchfieldexception e) {system.out.println e);} catch (securityException e) {system.out.println (e);} catch (illegalaccessExcection e) {system.out.println (e);}}} II, security and reflection: Safety during processing reflection Sex is a more complex problem. Reflection is often used by the frame type code. For this, we may wish that the framework can be fully access code without considering conventional access restrictions. However, in other cases, uncontrolled access will bring serious security risks, such as runtime when codes run in an environment where you are not worth trust. Due to these mutual contradictory needs, Java programming languages define a multi-level method to handle reflection security. The basic mode is the same restrictions on reflection and applied to source access: N from an access N-class itself from any location to a common component without any access N protected and packaged (default access The limited access of the component is not at least in some cases, and there is a simple method around these limits. We can extend a normal basic class java.lang.Reflect.accessibleObject class in the class we have written. This class defines a setAccessible method that enables us to start or close access detection of instances of these classes in these classes. The only problem is that if the security manager is used, it will detect whether the code that is closing access detection is licensed. If not permitted, the security manager throws an exception. Below is a program, using reflection on one instance of the TwoString class to display security is running: public class reflectsecurity {public static void main (string [] args) {try {twostring ts = new twostring ("a", "B "); Field Field = Clas.getDeclaredField (" m_s1 "); // field.setAccessible (true); system.out.println (" retrieved value is " field.get (inst));} catch (Exception EX) {EX.PrintStackTrace (System.out);}}} If we compile this program, do not use any specific parameters to run from the command line, which will throw an IllegalaccessException in the field .get (inst) call. If we don't comment the field.setaccessible (TRUE) code, then recompile and re-run the code, it will be compiled. Finally, if we add JVM parameters to the command line to implement the security manager, it will not be compiled unless we define the license permission for the ReflectSecurity class. Fourth, reflection performance: Reflection is a powerful tool, but there are some shortcomings. A main disadvantage is that there is an impact on performance. Using reflection is basically an explanation, we can tell JVM, what we want to do and it meets our requirements. This type of operation is always slower than only the same operation directly. The following program is an example of field access performance test, including basic test methods. Each method test field access is a form - AccessSame collaborate with the member field of the same object, Accessother uses a field of another object that can be accessed, and AccessReflection uses a field that can be reflected another object. In each case, the method performs the same calculation - a simple / multiplication order in the loop. Procedure is as follows: public int accessSame (int loops) {m_value = 0; for (int index = 0; index Conclusion: Java language reflection provides a multi-function method for dynamic link program components. It allows programs to create and control any class objects (depending on security restrictions), there is no need to hardly encode the target class in advance. These features make reflexes especially suitable for creating libraries that work with objects in very common ways. For example, reflecting is often used in a framework that continuously stores a database, XML, or other external format. Java Reflection is very useful, which enables class and data structures to dynamically retrieve relevant information by name and allow this information to be operated in the running program. This feature of Java is very powerful, and other common languages, such as C, C , Fortran or PASCAL, etc. But there are two shortcomings in reflection. The first is a performance problem. Reflection is slower than the direct code when accessing to fields and methods. Performance issues Depending on how the program is reflected in the program. If it is a relatively little part of the program run, the slow performance will not be a problem. Even if the reflection operation shown by the worst case in the worst case in the test consumes only a few microseconds. Performance issues are only critical to use only in the core logic of performance critical applications. A more serious disadvantage in many applications is that the use of reflexations will actually happen within the fuzzy program. The programmer wants to see the logic of the program in the source code, and the technique of reflection bypassing the source code will bring maintenance issues. The reflection code is more complicated than the corresponding direct code, as seen in the code instance of performance comparison. The best solution to these issues is to conservatively use reflection - only where it can truly increase flexibility - record their use in the target class. Dynamic loading Bromon original, please respect the copyright, you have recently written a mobile value-added project in Chengdu, and you are responsible for the background Server end. The function is very simple, and the mobile phone user opens the socket with the server via GPRS, and I respond according to the data passed by the user. Brothers who have done similar projects must know that first, a communication protocol similar to MSNP is needed, but today's topic is how to design this system highly scalable. Since this project itself did not have a relatively complete customer communication and demand analysis, there will be many functions in the future, and the communication agreement will definitely be more and more huge, and I as a less diligent person, of course, I don't want to go later. To modify the written program, this project is a good opportunity to practice object-oriented design. First define an interface to isolate the class: package org.bromon.reflect; public interface operator {public java.util.list act (java.util.list params)} According to the design mode, we can write different features. Class, each class inherits the Operator interface, and the client only needs to program a lot of trouble to program the Operator interface. For example, this category: package org.bromon.reflect. *; Public class surcess usList act (java.util.list params) {list result = new arraylist (); result.add (New String) "Successful operation")); Return Result;}} We can also write many other classes, but there is a problem, the interface is unprogable, we must manually control which class, which is very uncomfortable, if you can apply The program transmits a parameter, let yourself choose to instantiate a class, execute its ACT method, then our work is much easier. Very lucky, I am using Java, only Java provides such reflex mechanisms, or the internal provincial mechanism, can achieve our unreasonable requirements. Write a configuration file Emp.properties: # Successful Response 1000 = SUCCESS # Send a normal text message to the customer 2000 = LOAD # Customer Send a normal text message to the server 3000 = Store file The key name in the store is the message header that the customer will send me. The customer sends 1000 to me, then I will execute the Success class Act method. If you send me 2000, then execute the ACT method of the LOAD class, so that the system is fully compliant with the opening and closing principle, if you want to add new Function, there is no need to modify existing code, just add a corresponding rule in the configuration file, then write new classes, implement the ACT method is OK, even if I abandon this project, it will be well expanded in the future. Such systems have very good scalability and insertability.
