The existence of the problem is the kernel version 2.6.17 – 2.6.24.1.
    First of all, analyze the causes of overflow caused by:
   The role of Vmsplice a file descriptor (must be a pipe) and a memory linked with one another. The realization of this feature through the fs / splice.c the do_vmsplice () function to achieve, in the function of, the definition of the two arrays:
struct page * pages [PIPE_BUFFERS];
struct partial_page partial [PIPE_BUFFERS];
    PIPE_BUFFERS overflow in the presence of the value of the version of the problem is defined as 16. These two functions are passed to the get_iovec_page_array () this function in.
   To 2.6.22.14 version of the source code as an example, see fs / splice.c the beginning of the 1565 line get_iovec_page_array function.
In the function we see:
error = get_user (len, & iov-> iov_len);
if (unlikely (! len))
break;
Len here is only to determine a positive number on the ok, and the len can be controlled by user.
npages = (off + len + PAGE_SIZE – 1)>> PAGE_SHIFT;
if (npages> PIPE_BUFFERS – buffers)
    npages = PIPE_BUFFERS – buffers;
error = get_user_pages (current, current-> mm,
                    (unsigned long) base, npages, 0, 0, & pages [buffers], NULL);
npages the value is calculated through the len, then we will UINT32_MAX value is set to len, then the calculation of off + len + PAGE_SIZE the results will lead to a number of parcels integer (integer wrap), then the npages will be 0, this is the unexpected. We are now analyzing the get_user_pages have been unexpected in the npages value, what kind of results. get_user_pages is used to page the user space (pages) mapping (pin) into the memory, and to get their page structure (struct page) of the pointer. However, in get_user_pages () function inside the page used to deal with do () while () at the end is:
         len -;
     ) While (len & & start <vma-> vm_end);
If the value of len is 0, then (as we expected), then this cycle will cycle at least once, len value will be reduced to -1, the continued implementation of an error page until there is no effective implementation of the address mapping , the pointer will stop and return. However, at this time, he may have in reserve than he was allocated memory space more content to its page in the array. That is to say in this case get_user_pages () will overflow the array pages, wrote more than PIPE_BUFFERS (16) a pointer to the array. However, the actual experience of being overrun by the use of the procedure is the partial array array.
   In do_vmsplice () in the definition of the partial array of the same was passed on to the get_iovec_page_array (). In the partial array is described in the need to write to pipe in other parts of the page. In get_user_pages () return, followed by a loop:
for (i = 0; i <error; i + +) (
      const int plen = min_t (size_t, len, PAGE_SIZE – off);

      partial [buffers]. offset = off;
      partial [buffers]. len = plen;

      off = 0;
      len -= plen;
      buffers + +;
                 )
In this case, as all pages have been written by the calculated offset (offset) will be zero, and the length (length) value is PAGE_SIZE (4096). From get_user_pages () return value of the error, will be in the case of overflow pages have been mapped in the number of pages: 46. Partial effect, is the same array is defined as 16 elements, so the same top of this cycle will lead to the occurrence of overflow.
The two arrays are vmsplice_to_page () in the statement. Partial distribution of the memory array will be placed on the pages below, so that the partial array to be overflow, then this cycle will be the same on the top of the pages overflow the array. Therefore the contents of an array of pages will be rewritten to 0, rather than the previous structure of the indicators point to pages.
When these are completed, control returns to vmsplice_to_page () – overflow and insufficient to cover the return address. For splice_to_pipe () call it seems to end, but some interesting things happened. In the beginning of this function, there is a test:
     if (! pipe-> readers) (
         send_sig (SIGPIPE, current, 0);
         if (! ret)
             ret =-EPIPE;
         break;
     )
If we look at the attack code, we will see
         if (pipe (pi) <0) die ( “pipe”, errno);
         close (pi [0]);
In the call vmsplice () before the client will read the pipe closed. Splice_to_pipe will therefore immediately withdraw, however, to pull out, will perform the following steps:
     while (page_nr <spd_pages)
         page_cache_release (spd-> pages [page_nr ++]);
      We know get_user_pages () function will lock the call to the relevant pages in memory to allow access to its core; above two line is a code clean-up prior to return and unlock locked and no longer used in the present pages. However, in our example, pages of the contents of the array has been rewritten to 0. So what happens next will be to deceive the core (kernel oops), because the pages filled with the contents of the array is not a legitimate address. Overflow code through a number of small methods, such as the use of some specific mmap () call will be in memory address at the bottom of the contents of arbitrary structure.
    When running in kernel mode, go directly to user space even though the value of the pointer may cause a lot of problems, but indeed can be intolerable. If the address is valid and also the presence of memory-related, the value is less direct success. Kernel work when he thought it was the point in the struct page pointer of the memory space, he did not receive any error message; but has been constructed through the procedures exploit the content of the data.
      Under normal circumstances kernle will look for each individual page. However, in some cases, or have more than one page consisting of a collection known as the “compound pages”. This happens in a period was needed for kernel space for the size greater than the size of a page; When this call occurs, a group of compound pages to be passed to the caller. Rather special is that they were released, it will be removed separately, it would have split the action took place. Compound pages so there will be a general property pages do not: When the pages were released, we will call destructor.
We look at the attacks is how to set up procedures for low-memory page structures of:
     pages [0] -> flags = 1 <<PG_compound;
     pages [0] -> private = (unsigned long) pages [0];
     pages [0] -> count = 1;
     pages [1] -> lru.next = (long) kernel_code;
      When the kernel in user space and start looking for the 0 position when the page structure will be found that the page structure is a group of compound page. Destructor (stored in the first two page structure lru.next) the point is that exploit code for some previously defined kernel_code (). Because the count is set to 1, therefore the implementation of page_cache_release () (the count value by 1) that would produce the target, no spare, and this page looks like a section of compound page, destructor will be called. At this time, stored in the location of kernel_code arbitrary code can be run in kernel state.

    First of all, to tell us what is Quick I / O combined Cached Quick I / O. VERITAS Quick I / O is the oracle database VXFS for a special function. Database and file system integrated with organic at the same time a better help system administrators and database administrators to configure the database server oralce. At the same time, VERITAS Quick I / O is also for the creation of common documents to provide the bare device interface. It must avoid the overhead of file system operation (such as: data lock level operation) to provide kernel asynchronous I / 0 (KAIO), therefore, Quick I / O for file system management and performance of equipment with bare to expediency. Cached Quick I / O is an enhanced Quick I / O, it can help better use of oracle DBA memory efficiency of large-scale systems.
     In other words, the traditional file system, as a result of the document the existence of single write lock, leading to the file system read and write in the complicated environment of relatively low efficiency. Bare equipment and the problem does not exist. Quick I / O is actually the elimination of a single write lock on the file system to improve efficiency.
     Cached Quick I / O is the Quick I / O of an enhanced deal with the ideological core of the record of the visit is to continue to document the frequency, the document will be the hottest on the cache, the cache hit rate to increase, thereby enhancing the document efficiency of the system.
Use Cached Quick I / O can be better run in the file system database.
System to facilitate the provision of the document production environment I / O statistics.
    Collection of documents in the file I / O statistics.
Use Cached Quick I / O to facilitate analysis of the I / O statistics.
Do not use Cached Quick I / O in a larger percentage difference.
A simple understanding of these two characteristics:
1) Quick I / O address is the traditional unix file system the issue of single write lock.
2) Cached Quick I / O address is the cache hit rate.

First to introduce the Quick I / O.
    First of all, to confirm that the file system is vxfs. This is characteristic of the VERITAS storage foundation.
    Need to buy veritas license
    Veritas provided by the use of scripts to create the data files needed to be translated into a list of
  $ / opt / VRTSdbed / bin / qio_getdbfiles the implementation of the script may be needed to be translated into all vxfs data files are output to mkqio.dat file. Script directory in / opt / VRTSdbed / bin. Version of the old name of this script: getdbfiles.sh.
     This script will automatically rule out all types of data files for temproary. After the conversion of these documents, oracle will not be able to write.
  mkqio.dat documents can also create their own hand. However, we must pay attention to rule out temporary datafiles. File contains data files and the size of sample is as follows:

$ cat mkqio.dat
/ db01/file1 210358
/ db01/file2 157996
/ db01/file3 38098
/ db01/file4 394935
/ db01/file5 911787
/ db01/redo_t04.log 209715
In the above process, the need to open the database.

  $ / opt / VRTSdbed / bin / qio_convertdbfiles, the implementation of the script into mkqio.dat data files in the list. Version of the old name of this script: mkqio.sh
Before the conversion, you must first close the database.
These scripts are oracle user.
Let me now how to enable Cached Quick I / O do? Vxtunefs can order through the use of qio_cache_enable signs order to set to 1. Command as follows:

# Vxtunefs-s-o qio_cache_enable = 1 / mount_point

For example:

# / Opt / VRTSvxfs / sbin / vxtunefs-s-o qio_cache_enable = 1 / happy

vxfs vxtunefs: Parameters successfully set for / happy

Then see how close the Cached Quick I / O do? Vxtunefs can order through the use of the command will be changed to 0 to qio_cache_enable logo set. Command as follows:

# Vxtunefs-s-o qio_cache_enable = 0 / mount_point

For example:

# / Opt / VRTSvxfs / sbin / vxtunefs-s-o qio_cache_enable = 0 / happy1

vxfs vxtunefs: Parameters successfully set for / happy1

If you want Cached Quick I / O settings without restarting the impact of fixed, on the need to / etc / vx / tunefstab file the following entry qio_cache_enable increase.
If that does not exist tunefstab words, one needs to add a hand on it.
For example:
/ dev / vx / dsk / datadg / datavol qio_cache_enable = 1
/ dev / vx / dsk / datadg / myvol qio_cache_enable = 1

Can vxtunefs command to view the Cached Quick I / O situation.
Command as follows:
# Vxtunefs / mount_point

For example:
# / Opt / VRTSvxfs / sbin / vxtunefs / happy
Filesystem i / o parameters for / happy
read_pref_io = 65536
read_nstream = 1
read_unit_io = 65536
write_pref_io = 65536
write_nstream = 1
write_unit_io = 65536
pref_strength = 10
buf_breakup_size = 131072
discovered_direct_iosz = 262144
max_direct_iosz = 1048576
default_indir_size = 8192
qio_cache_enable = 1
write_throttle = 15104
max_diskq = 1048576
initial_extent_size = 8
max_seqio_extent_size = 2048
max_buf_data_size = 8192
hsm_write_prealloc = 0

# / Opt / VRTSvxfs / sbin / vxtunefs / happy1
Filesystem i / o parameters for / happy1
read_pref_io = 65536
read_nstream = 1
read_unit_io = 65536
write_pref_io = 65536
write_nstream = 1
write_unit_io = 65536
pref_strength = 10
buf_breakup_size = 131072
discovered_direct_iosz = 262144
max_direct_iosz = 1048576
default_indir_size = 8192
qio_cache_enable = 0
write_throttle = 15104
max_diskq = 1048576
initial_extent_size = 8
max_seqio_extent_size = 2048
max_buf_data_size = 8192
hsm_write_prealloc = 0

At the same time, individual documents can also set up Cached Quick I / O. Qioadmin order to set up the use of documents Cached Quick I / O. Qiostat or other use of analytical tools to analyze the documents Cached Quick I / O. When individuals file to open and close the Cached Quick I / O requires the database is running. Qiostat through the use of document order to observe whether the cache hit rate sufficient to open or closed to change the Cached Quick I / O for individual files also need to consider setting up cache.
Close personal documents Cached Quick I / O command set used qioadmin flag OFF.
Command as follows:
# Qioadmin-S file = OFF mount_point
For example:
# / Opt / VRTSvxfs / sbin / qioadmin-S myfile = OFF / happy

Open the personal files of Cached Quick I / O command set used qioadmin flag ON.
Command as follows:
# Qioadmin-S file = ON mount_point
For example:
# / Opt / VRTSvxfs / sbin / qioadmin-S myfile = ON / happy

If you want to set up has been the entry into force of the impact from the need to restart the file / etc / vx / qioadmin entries corresponding increase.
If this file does not exist, you can manually add up.
recommend the use of cache to store qioadmin need to add attributes Inode. These settings can be re-mount and system restart has been the entry into force, but these attributes through general backup methods can not be backed up. They can not be restored, so that any restoration of a file system needs to re-set attributes. If the / etc / vx / qioadmin increase of Quick I / O file system entries, these do not need to do work.

/ etc / vx / qioadmin the contents of the paper is as follows:
Happy in the file system as an example:
device = / dev / vx / dsk / datadg / datavol
myfile, OFF
mydata, ON

Qioadmin can use the-P option command to view the document now Cached Quick I / O situation.
Command as follows:
# Qioadmin-P file mount_point

For example:

# / Opt / VRTSvxfs / sbin / qioadmin-P myfile / happy

myfile, OFF

# / Opt / VRTSvxfs / sbin / qioadmin-P mydata / happy

mydata, ON

Socket is often referred to as the so-called “socket” used to describe the IP address and port, is a communications chain handle. Applications are usually through the “socket” to the network response to a request or the request of the network. Socket and ServerSocket class library is located in the java.net package. ServerSocket for server-side, Socket is to establish a network connection used. The connection is successful, the application will have two ends of a Socket instance, the operation of this example, the completion of the necessary conversation. For a network connection, the socket is equal, and there is no difference, not because the server side or on the client arising from different levels. Socket or ServerSocket whether their work is through the class and its subclasses SocketImpl completed.

The following is one of the most simple example of Socket Communications for beginners reference:

Server-side: ServerDemo.java

package com.lanber.socket;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo (

/ **
* Note: Socket is the need to send and receive simultaneously, that is, the client sends a message, the server must first receive this information,
* And before they can send a message to the client, otherwise there will be a run-time error.
* @ Param args
* /
public static void main (String [] args) (
ServerSocket ss = null;
try (
ss = new ServerSocket (8888);
/ / Server to the client receiving the data, create a dialogue with the Socket Client
Socket socket = ss.accept ();
/ / For sending data to the client’s output stream
DataOutputStream dos = new DataOutputStream (socket.getOutputStream ());
/ / For the client to receive data sent by the input stream
DataInputStream dis = new DataInputStream (socket.getInputStream ());
System.out.println ( “server to the client to receive connection requests:” + dis.readUTF ());
/ / Server to the client to send information to connect successfully identified
dos.writeUTF ( “accept connection requests, connection successful!”);
/ / Do not need to continue to use this connection, close connection
socket.close ();
ss.close ();
) Catch (IOException e) (
e.printStackTrace ();
)
)

)

Client: ClientDemo.java

package com.lanber.socket;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientDemo (

/ **
* @ Param args
* /
public static void main (String [] args) (
Socket socket = null;
try (
socket = new Socket ( “localhost”, 8888);
/ / Obtain output stream for the client to send data to the server-side
DataOutputStream dos = new DataOutputStream (socket.getOutputStream ());
/ / Obtain the input stream, the server side for receiving the data sent
DataInputStream dis = new DataInputStream (socket.getInputStream ());
/ / Client sends data to the server-side
dos.writeUTF ( “I am a client, a request to connect!”);
/ / Print received from the server data termination
System.out.println (dis.readUTF ());
/ / Do not need to continue to use this connection, I recall that the closure of O
socket.close ();
) Catch (UnknownHostException e) (
e.printStackTrace ();
) Catch (IOException e) (
e.printStackTrace ();
)
)

)

Java language to introduce the Java virtual machine, running with the cross-platform functionality, able to adapt to a variety of Web applications. At the same time, Java language in order to improve the performance and robustness, but also the introduction of mechanisms such as garbage collection and other new features, through these improvements so that Java has its own unique works.

1. Java Virtual Machine

Java Virtual Machine (Java Virtual Machine, JVM) is a computer simulation software, it can be in any processor (whether in the computer or other electronic equipment) compliant implementation of the security stored in. Class file byte code . Java Virtual Machine “Machine Code” kept in. Class files, and sometimes can also be referred to as byte-code files.

Cross-platform Java program characteristics mainly refer to byte-code files can be in any Java virtual machine with a computer or electronic devices, Java Virtual Machine in the Java interpreter is responsible for the interpretation of byte-code file to run a particular binary . So at runtime, Java source code need to be a compiler to compile. Class files.

Java virtual machine to establish the need for different hardware and software platform to achieve, it is necessary to consider the processor model, we should also consider the type of operating system. Resulting in the SPARC structure, X86 structure, MIPS and PPC chips, such as embedded processing, in UNIX, Linux, Windows, and some real-time operating system on the Java virtual machine can be realized.

2. Automatic recovery mechanism useless memory

In the course of the implementation of the procedures, some of the memory in use after the middle of the abandoned state, if we do not recover in time, is likely to lead to memory leaks, which lead to system crashes. In C + + language by the programmer to carry out the recovery of memory, programmers need to program in the preparation of the object to the use of memory is no longer off the release of this man-made memory management method of release is often due to the negligence of a programmer can not recall a result of memory At the same time also increased the workload of programmers. Running in the Java environment, there is always a system-level threads, dedicated to track memory usage, no longer used regularly to detect the memory, and automatically recover and avoid a memory leak, but also to reduce the programmers workload.

3. Code security checking mechanism

Always a relatively safe and convenient contradictory. The emergence of Java programming language allows the client computer from the network can easily upload or download the Java program to run on the local computer, but how to ensure that the Java program does not carry the risk of viruses or any other purpose? In order to ensure that procedures for the implementation of Java security, Java language through the procedures to control illegal Applet security procedures, that is, it only has to ensure that the Java language’s survival.

The implementation of Java byte code to go through the following three steps:

(1) classloader (class loader) is responsible for the class file (. Class files) loaded into the Java virtual machine. In the process of such documents need to be inspected in line with the class file specification.

(2) byte-code validator (bytecode verifier) to check the code of such a document the existence of some illegal operation, such as programs written Applet local computer file system.

(3) If the byte-code validator test passed, by the Java interpreter is responsible for the interpretation of such documents for the implementation of Machine Code.

Note:

Java virtual machine “sandbox” mode, that is, the Java program code and data are limited to the implementation of a certain memory space, does not allow access outside the memory space of memory. Applet process if it is also not allowed to visit the client machine file system.
Java Runtime Environment

No matter what language it requires a specific operating environment, which is the platform. Java is no exception to the same language. But how to understand the procedures and hardware environment Java has nothing to do it?

Almost all the languages through an interpretation of the compiler or the computer can be implemented, but a little different from Java, it needs these two processes at the same time. In fact, for this reason it is only to make Java the language has nothing to do with the platform of. When, after the completion of a Java source code, first of all, through the Java compiler translation process it into an intermediate byte code called code, and then explained by the Java platform as a device to convert it to machine language implementation of the core of this platform is JVM.

The process of compiling Java and other languages. Such as C + + language, it is a compile-time in the computer hardware platform information inseparable. Compiler directives through look-up table of all the operands and opcode into memory, such as offset, that is, running the memory allocation procedures designed to ensure normal operation. Java is the conversion will become a kind of instruction. Class files, this file does not contain hardware information, the need for as long as after the implementation of the machines installed JVM to explain, after the creation of memory allocation through the look-up table to determine where a directive address. This will effectively ensure the portability of Java and security.

Java platform with such features and its structure. Usually a program running on a platform is a hardware or software environment is currently more popular Windows XP, Linux, Solaris and MacOS. Not as a platform for Java, which is composed of two parts, namely, JVM and application programming interface.

1. JVM

JVM is the core Java platform, in order to allow the compiler to generate the byte code interpretation and implementation of better, so the JVM has been divided into six parts: JVM interpreter, command systems, registers, stacks, storage areas and debris recovery area.

◆ JVM interpreter: that is, the virtual machine code to deal with field CPU.

◆ JVM command system: the system is very similar to the computer, a command from the operation code and operands of two parts. Opcode for an 8-bit binary number, mainly to illustrate the function of a command, the operation could be based on needs, JVM as many as 256 kinds of different operating instructions.

◆ register: JVM has its own virtual register so that you can quickly and JVM interpreter of data exchange. Needs in order to function, JVM settings of the four commonly used 32-bit registers: pc (program counter), optop (Top-pointer operand), frame (the current implementation of environmental indicators) and vars (point to the current environment, implementation of the first local variable pointer).

◆ JVM stack: instruction execution data and information stored at the sites and the control center, which provides JVM interpreter to the computing the required information.

◆ Storage Area: JVM memory used to store the byte-code compiler, such as after the information.

◆ debris recovery area: JVM debris recovery refers to the use of the Java type of concrete examples to recall from memory, which allows developers to program their own control eliminates the trouble and the risk of memory. With the continuing escalation of JVM, the debris recovery techniques and algorithms are also more reasonable. JVM 1.4.1 version is called after hours on behalf of a collection of technologies, the use of the object is simply to survive in the procedure time is divided into generation, as debris recycling standards.

2. Java Application Programming Interface

Java Application Programming Interface referred to as Java API, the Chinese called Java Application Programming Interface. It is a software collection, many of which required the development of the control, you can use it to support the development.

Java API and JVM running Java constitutes a basic environment, and these two together in the computer software on through these two software, Java platform, a Java application separated from the hardware system, which guarantees a very good program independence. In order to better adapt to the needs of development, Java’s designers have provided three kinds of versions of Java platform: Java 2 Micro Edition (J2ME), Java 2 Standard Edition (J2SE) and Java 2 Enterprise Edition (J2EE), each version provides a wealth of development tools to meet the different needs of the development.

Java Swing learned some of the readers of the Swing relatively complex event-driven model is confusing, although the event-driven model in Java Swing was reflected entirely, but for a beginner in terms of software this sort of “naked “The event-driven model is very difficult to understand.

Microsoft Corporation. Net Framework and Java Swing for GUI programming is much simpler compared to the same event-driven model. Net framework to deal with a large number of packages,. Net commission called this package browser (Delegate) its code is as follows:

/ / When the button is clicked after btnSubmit asked to approach btnSubmit_Click
/ / EventHandler Kai in the middle to the commission’s role
/ / It is responsible for the distribution of the incident to a specific method to deal with
this.btnSubmit.Click + = new EventHandler (this.btnSubmit_Click);
/ / Event handling methods
/ / Object sender: event source, in this case the object btnSubmit
/ / EventArgs e: event handling parameters, save it to the programmers of the need to provide the necessary information
private void btnSubmit_Click (object sender, EventArgs e)
(
/ / This is a button to print statements
System.Diagnostics.Debug.WriteLine ( “This is button”);
)

In contrast, we take a look at the Java Swing event handling, and commissioning will be many complex: the code is as follows: (If you do not understand the Swing is event-driven, you can refer to my other article: Detailed examples of event-driven model ( Java chapter)):

/ / Listener for btnSubmit increase SelectHandler, when clicked after btnSubmit
/ / There is the actionPerformed listener to handle the Click event of the business
/ / Since the incident btnSubmit source and listener SelectHandler in two different categories of class
/ / In order to obtain SelectHandler pages categories, we need to form the object (this)
/ / Imported to the listener in
btnSubmit.addActionListener (new SelectHandler (this));
/ / Listener SelectHandler, it must be action to achieve the incident interface ActionListener
/ / In order to achieve the role of the distribution of the incident
class SelectHandler implements ActionListener (
Private CommonDialogDemo form = null;
/ / Will form the object through the constructor CommonDialogDemo incoming class SelectHandler
Public SelectHandler (CommonDialogDemo form) (
This.form = form;
)
/ / Event handler method, when clicked btnSubmit automatically print the following code
Publicvoid actionPerformed (ActionEvent e) (
System.out.println ( “This is button”);
)
)

Based on the above code, we can clearly see that the Java Swing than. Net of trouble more and more people can not put up with is that if there is more than one page button, we must prepare for each button a number of events detected listening categories, and these categories will be set within the general category. Modeling software to learn the readers may know, the internal model in the software engineering in the software is not recommended, therefore, the preparation of the code will increase significantly the design of redundancy and complexity, so we can consider themselves similar to the preparation of a . Net in the same event EventHandler to entrust the distribution of categories to deal with the incident.

Since we have no right to modify the Java compiler, so I will be here through the use of reflection technique, using an event-type commission to deal with all the click events, the code is as follows:

package cn.softworks.teachersearchsystem.support;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Method;

/ **
* Type is used to deal with all of the Swing button click events, and will be dealt with in accordance with the right to <br>
* To the user to deal with
*
* @ authorChen.yu
*
* /
publicclass EventHandlerimplements ActionListener (

/ / Components which form the object
Private Object form = null;

/ / By way of commission
Private String methodName = null;

/ **
* Constructor
*
* @ Paramform object components which form
* @ ParammethodName commissioned by the method of
* /
public EventHandler (Object form, String methodName) (
This.form = form;
This.methodName = methodName;
)

/ **
* Event handler methods to entrust
* /
Publicvoid actionPerformed (ActionEvent e) (

/ / Get the type of object form
Class formType = this.form.getClass ();

Try (
/ / Get the type of the specified method commissioned
Method method =
formType.getMethod (this.methodName, new Class [] (e.getClass ()});
/ / Call the specified method
method.invoke (this.form, new Object [] (e));

) Catch (Exception ex) (
Return;
)
)
)

Now we come to the preparation of a test procedure, the code is as follows:

btnSearch.addActionListener (new EventHandler (this, “btnSearch_Click”));

public void btnSearch_Click (ActionEvent e) (
System.out.println ( “This is btnSearch”);
)

Code from the above we can clearly see that the event handler and commissioned at the same event in the form,. Net to facilitate the handling of the Delegate reflection we realized.

Generic is the Java SE 1.5 new features, the nature of generic type parameters, that is operated by the data type is designated as a parameter. This parameter type can be used in class, the creation of interfaces and methods of the respective category as generic, generic interfaces, generic approach.

Java language advantages of the introduction of generic security simple.

Before in the Java SE 1.5, the situation is not generic, by reference to the type of Object parameters to achieve the “arbitrary” and “arbitrary” and bring the disadvantage is that mandatory to do explicit type conversion, which conversion is to ask the developers of the actual parameters of the type of unforeseen circumstances can be carried out. The mandatory type conversion error, the compiler may not be prompted error when running unusual, this is a security risk.

The advantage of generics at compile time to check the type of security, and forced conversion are all automatic and implicit, and to improve the rate of code reuse.

Generic in use there are some rules and restrictions:

1, the generic type parameter can only be a class type (including custom type), can not be a simple type.

2, with a corresponding number of generic versions can be (because the type is uncertain parameters), different versions of the generic category of examples is not compatible.

3, generic type parameter can have more than one.

4, the parameters of generic types can use the extends statement, for example, <T extends superclass>. Become accustomed to “bounded type.”

5, the generic type parameter type can also be a wildcard. For instance, Class <?> ClassType = Class.forName (java.lang.String);

There are generic interfaces, methods, etc., as many take some martial arts and skilled in order to understand and master the application. In this paper I have time to write a generic understanding of the two examples (see the impression in accordance with written), to achieve the same function, the use of a generic, one did not use, by contrast, can quickly learn the generic applications, the Institute learned that basically 70% of the contents of generic.

One example: the use of generic

public class Gen <T> (
Private T ob; / / define generic member variable

Public Gen (T ob) (
This.ob = ob;
)

Public T getOb () (
Return ob;
)

Public void setOb (T ob) (
This.ob = ob;
)

Public void showTyep () (
System.out.println ( “T is the actual type:” + ob.getClass (). GetName ());
)
)

public class GenDemo (
Public static void main (String [] args) (
/ / Definition of a generic type Integer version of Gen
Gen <Integer> intOb = new Gen <Integer> (88);
IntOb.showTyep ();
Int i = intOb.getOb ();
System.out.println ( “value =” + i);

System.out.println (”———————————-”);

/ / Definition of a generic type String version of Gen
Gen <String> strOb = new Gen <String> ( “Hello Gen!”);
StrOb.showTyep ();
String s = strOb.getOb ();
System.out.println ( “value =” + s);
)
)

Second example: do not use the generic

public class Gen2 (
private Object ob; / / definition of a common type of the members of

Public Gen2 (Object ob) (
This.ob = ob;
)

Public Object getOb () (
Return ob;
)

Public void setOb (Object ob) (
This.ob = ob;
)

Public void showTyep () (
System.out.println ( “T is the actual type:” + ob.getClass (). GetName ());
)
)

public class GenDemo2 (
Public static void main (String [] args) (
/ / Definition of an Integer-type version of Gen2
Gen2 intOb = new Gen2 (new Integer (88));
IntOb.showTyep ();
Int i = (Integer) intOb.getOb ();
System.out.println ( “value =” + i);

System.out.println (”———————————-”);

/ / Define category Gen2 version of a String
Gen2 strOb = new Gen2 ( “Hello Gen!”);
StrOb.showTyep ();
String s = (String) strOb.getOb ();
System.out.println ( “value =” + s);
)
)

Results:

Demo the results of running two examples are the same, the console output is as follows:

The actual type of T is:

java.lang.Integer
value = 88
———————————-
T is the actual type: java.lang.String
value = Hello Gen!

Process finished with exit code 0

Understand this, since the basic applications and the generic code readers can not be a problem.