Kelas proxy dinamis Java terletak di bawah paket java.lang.reflect, dan umumnya terutama melibatkan dua kelas berikut:
(1) InvocationHandler: Hanya satu metode yang didefinisikan dalam antarmuka ini
Invoke Objek Publik (objek OBJ, metode metode, objek [] args)
Dalam penggunaan aktual, parameter pertama OBJ umumnya mengacu pada kelas proxy, metode adalah metode proxy, seperti permintaan () dalam contoh di atas, ARGS adalah array parameter metode. Metode abstrak ini diimplementasikan secara dinamis di kelas proxy.
(2) Proxy: Kelas ini adalah kelas proxy dinamis, dan fungsinya mirip dengan proxysubject dalam contoh di atas, yang terutama berisi konten berikut proxy yang dilindungi (InvocationHandler H): Konstruktor, yang digunakan untuk menetapkan nilai ke internal h.
kelas statis getProxyClass (classloader loader, class [] antarmuka)
Dapatkan kelas proxy di mana loader adalah class loader dan antarmuka adalah array dari semua antarmuka yang dimiliki oleh kelas nyata.
Objek Statis NewProxyInstance (ClassLoader Loader, Class [] Antarmuka, InvocationHandler H)
Mengembalikan contoh kelas proxy.
Yang disebut proxy dinamis adalah kelas: itu adalah kelas yang dihasilkan saat runtime. Tentu saja Anda dapat menggunakan instance dari kelas sebagai antarmuka ini. Tentu saja, proxy dinamis ini sebenarnya adalah proxy, yang tidak akan melakukan pekerjaan besar untuk Anda.
Saat menggunakan kelas proxy dinamis, kita harus mengimplementasikan antarmuka InvocationHandler:
Lihat program subjek.java
Lihat program realsubject.java
Lihat Program Dynamicsubject.java
Lihat Program Client.java
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
// Peran abstrak (sebelumnya adalah kelas abstrak, harus diubah menjadi antarmuka di sini):
subjek antarmuka publik
{
abstrak permintaan public void ();
}
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
// Peran spesifik
Subjek Realsubject Kelas Publik
{
Public RealSubject ()
{
}
Permintaan public void ()
{
System.out.println ("Dari subjek nyata.");
}
}
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
impor java.lang.reflect.invocationHandler;
impor java.lang.reflect.method;
// prosesor proxy
/**
* Properti internal kelas proxy adalah kelas objek.
* Selain itu, metode Invoke juga diimplementasikan di kelas ini, method.invoke (sub, args);
* Faktanya, itu untuk memanggil metode yang akan dieksekusi oleh objek proxy.
* ARGS adalah parameter yang diperlukan untuk melakukan operasi yang sesuai dari objek proxy.
* Melalui kelas proxy dinamis, kami dapat melakukan beberapa operasi terkait sebelum atau setelah panggilan
*/
Kelas Publik Dynamicsubject mengimplementasikan InvocationHandler
{
Sub Objek Pribadi;
public dynamicsubject ()
{
}
Public Dynamicsubject (Object Obj)
{
sub = obj;
}
Invoke Objek Publik (Proksi Objek, Metode Metode, Objek [] args) melempar yang dapat dilemparkan
{
System.out.println ("Sebelum memanggil" Metode +);
method.invoke (sub, args);
System.out.println ("After Calling" + Metode);
kembali nol;
}
}
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
impor java.lang.reflect.invocationHandler;
impor java.lang.reflect.proxy;
//Klien
Klien Kelas Publik
{
statis public void main (string [] args) melempar lempar
{
Realsubject rs = new realsubject (); // Tentukan kelas proxy di sini
InvocationHandler DS = new DynamicSubject (RS);
Kelas <?> Cls = rs.getClass ();
// Berikut ini adalah agen generasi satu kali
Subjek subjek = (subjek) proxy.newproxyInstance (
cls.getclassloader (), cls.getInterfaces (), ds);
Subject.Request ();
}
}
Contoh 2:
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
impor java.lang.reflect.invocationHandler;
impor java.lang.reflect.method;
impor java.lang.reflect.proxy;
impor java.util.list;
impor java.util.vector;
Vektorproxy kelas publik mengimplementasikan InvocationHandler
{
Proxyobj objek pribadi;
Public VectorProxy (Object Obj) {
proxyobj = obj;
}
Public Static Object Factory (Object Obj) {
Kelas <?> Cls = obj.getClass ();
return proxy.newProxyInstance (cls.getClassLoader (), cls.getInterfaces (), vectorproxy baru (OBJ));
}
Invoke Objek Publik (Proxy Objek, Metode Metode, Objek [] args) melempar lempar {
System.out.println ("Sebelum memanggil" Metode +);
if (args! = null) {
untuk (int i = 0; i <args.length; i ++) {
System.out.println (args [i] + "");
}
}
Objek objek = method.invoke (proxyobj, args);
System.out.println ("After Calling" + Metode);
objek pengembalian;
}
@SuppressWarnings ("Uncecked")
public static void main (string [] args) {
Daftar <string> v = (Daftar <String>) Factory (vektor baru <string> (10));
v.add ("baru");
V.Add ("York");
System.out.println (v);
V.Remove (0);
System.out.println (v);
}
}
Contoh 3.
Salinan kode adalah sebagai berikut:
paket com.langsin.dynamicproxy;
antarmuka publik foo {
void doaction ();
}
paket com.langsin.dynamicproxy;
Kelas publik fooImpl mengimplementasikan foo {
fooImpl public () {
}
public void doaction () {
System.out.println ("Dalam fooIMP1.DoAction ()");
}
}
paket com.langsin.dynamicproxy;
Kelas publik FooImpl2 mengimplementasikan foo {
fooImpl2 publik () {
}
public void doaction () {
System.out.println ("di fooimp2.doaction ()");
}
}
paket com.langsin.dynamicproxy;
impor java.lang.reflect.invocationHandler;
impor java.lang.reflect.method;
Public Class CommonInVocationHandler mengimplementasikan InvocationHandler {
// Eksekusi objek yang dinamis, objek yang membutuhkan panggilan balik
target objek pribadi;
// mendukung injeksi konstruktor
public commonInvocationHandler () {
}
// mendukung injeksi konstruktor
Public CommonInVocationHandler (Target Objek) {
setarget (target);
}
/**
*
* Gunakan metode setter untuk menyuntikkan
*
* @param target
*
*/
public void setTarget (objek target) {
this.target = target;
}
/**
*
* Panggil metode yang ditentukan dalam proxy dan lulus dalam daftar parameter args
*
* @param proxy
* Jenis kelas proxy, seperti mendefinisikan antarmuka proxy yang sesuai dengan metode ini
*
* Metode @param
* Metode proxyed
*
* @param args
* Parameter yang memanggil metode proxy
*
* @kembali
*
* @Throws java.lang.Trowable
*
*/
Invoke Objek Publik (Proxy Objek, Metode Metode, Objek [] args) melempar lempar {
return method.invoke (target, args);
}
}
paket com.langsin.dynamicproxy;
impor java.lang.reflect.proxy;
demo kelas publik {
public static void main (string [] args) {
// 1. Implementasi proxy dinamis umum
CommonInvocationHandler handler = new CommonInvocationHandler ();
Foo f;
// 2. Implementasi Antarmuka 1
handler.setarget (fooImpl () baru);
// Metode Parameter Deskripsi: kelas proxy, daftar implementasi kelas proxy, prosesor kelas proxy
// Hubungkan kelas proxy, metode antarmuka, dan prosesor di kelas proxy. Ketika metode antarmuka di kelas proxy dipanggil, mereka akan secara otomatis didistribusikan ke metode Invoke prosesor.
// Jika kelas proxy tidak mengimplementasikan daftar antarmuka yang ditentukan, pengecualian parameter ilegal akan dilemparkan
f = (foo) proxy.newproxyInstance (foo.class.getClassLoader (),
kelas baru [] {foo.class},
pawang);
f.doaction ();
// 3. Implementasi antarmuka 2
handler.setarget (fooImpl2 ()) baru;
f = (foo) proxy.newproxyInstance (foo.class.getClassLoader (),
kelas baru [] {foo.class},
pawang);
f.doaction ();
}
}
Karena saya memiliki bakat sastra terbatas, sebagian besar konten adalah kode