Shulou(Shulou.com)06/01 Report--

This article introduces the knowledge of "what is the loading and reflection mechanism of Java assemblies". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

I. loading of assemblies

When the JIT compiler compiles the IL code into native code, it looks at which types are referenced in the IL code. At run time, the JIT compiler uses the assembly's TypeRef and assemblyRef metadata tables to determine which assembly defines the referenced type, and then the JIT compiler loads the corresponding assembly into AppDomain, and internally, CLR uses the static method Load of the System.Reflection.Assembly class to try to load an assembly. However, if we want to load an assembly dynamically, we can use the Load method of Assembly to load the assembly dynamically, and other assembly loading methods are provided in the Assembly class, such as LoadFrom (string path), LoadFile (stringassemblyFile), and so on.

Second, reflection mechanism

The reflection in. Net parses the metadata in the assembly while it is running to get the information about the members of the type (including fields, constructors, methods, properties, events, and so on).

Dynamically load an assembly and get the members of the type

Put the following classes in a class library project and compile to generate the assembly (for example, ClassLibrary1.dll, suppose you put dll under the D root directory)

Public class ReflectTestClass {public string name; public int age; public string Name {get {return name;} set {name = value;}} public int Age {get {return age;} set {age = value }} / No Paramter Constructor / public ReflectTestClass () {} / Constructor with Parameter / public ReflectTestClass (string names,int ages) {this.name = names This.age = ages;} public string writeString (string name) {return "Welcome" + name;} public static string WriteName (string name) {return "Welcome" + name + "Come here";} public string WirteNopara () {return "The method is no parameter";}}

Then set up a console program to dynamically load the members of the above generated assemblies and output types, which are described in detail in the code.

Class Program {static void Main (string [] args) {Assembly ass; Type [] types; Type typeA; object obj Try {/ / loads the assembly locally and then gets the type information from the assembly by reflection, and calls the method ass = Assembly.LoadFrom (@ "D:\ ClassLibrary1.dll"); types = ass.GetTypes () Foreach (Type type in types) {Console.WriteLine ("Class Name is" + type.FullName); Console.WriteLine ("Constructor Information"); Console.WriteLine ("- -") / / get the structure information of the type ConstructorInfo [] myconstructors = type.GetConstructors (); ShowMessage (myconstructors); Console.WriteLine ("Fields Information"); Console.WriteLine ("- -") / / get field information of type FieldInfo [] myfields = type.GetFields (); ShowMessage (myfields); Console.WriteLine ("All Methods Information"); Console.WriteLine ("- -") / / get method information MethodInfo [] myMethodInfo = type.GetMethods (); ShowMessage (myMethodInfo); Console.WriteLine ("All Properties Information"); Console.WriteLine ("- -") / / get attribute information PropertyInfo [] myproperties = type.GetProperties (); ShowMessage (myproperties);} / / get type typeA = ass.GetType ("ClassLibrary1.ReflectTestClass") with namespace + class name / / get the method name MethodInfo method = typeA.GetMethod ("writeString"); / / create an instance obj = ass.CreateInstance ("ClassLibrary1.ReflectTestClass"); string result = (String) method.Invoke (obj,new string [] {"Tom"}) Console.WriteLine ("Invoke Method With Parameter"); Console.WriteLine ("- -"); Console.WriteLine (result); Console.WriteLine ("- -"); Console.WriteLine () Method = typeA.GetMethod ("WriteName"); result = (string) method.Invoke (null,new string [] {"Tom"}); Console.WriteLine ("Invoke Static Method with Parameter"); Console.WriteLine ("- -"); Console.WriteLine (result) Console.WriteLine ("- -"); Console.WriteLine (); method = typeA.GetMethod ("WirteNopara"); Console.WriteLine ("Invoke Method with NOParameter"); result = (string) method.Invoke (obj, null) Console.WriteLine ("- -"); Console.WriteLine (result); Console.WriteLine ("- -") } catch (FileNotFoundException ex) {Console.WriteLine (ex.Message);} Console.ReadLine () } / display array information / public static void ShowMessage (T [] array) {foreach (T member in array) {Console.WriteLine (member.ToString ()) } Console.WriteLine ("- -"); Console.WriteLine ();}}

Filter the types of members returned

You can call the GetMembers,GetFields,GetMethods,GetProperties or GetEvenents method of Type to query the members of a type. When calling any of the above methods, you can pass an instance of the System.Reflection.BindingFlags enumerated type, which is used to filter the members returned by these methods.

Note: of all methods that return a collection of members, there is an overloaded version that does not get any arguments. If the BindingFlags argument is not passed, all of these methods return public members. The default setting is BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static. If you specify Public or NonPublic, you must also specify Instance, otherwise no members are returned.

That's all for "what is the mechanism for loading and reflecting Java assemblies?" Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.