So implementieren Sie eine einfache Interceptor-Operation in Java über einen dynamischen Proxy

1. Proxy

Bevor wir dynamische Proxys zur Implementierung von Interceptoren verwenden, wollen wir zunächst kurz verstehen, was Java-Proxys sind.

Agent betreibt, wie der Name schon sagt, nicht direkt das Objekt, das als Proxy fungiert (im Folgenden als Zielobjekt bezeichnet, was komfortabler klingt), sondern verwendet indirekt die Methoden im Zielobjekt über einen Proxy Objekt. Agenten sind in zwei Modi unterteilt: einen statischen Agenten und einen dynamischen Agenten. Schreiben Sie als Nächstes ein Beispiel für einen statischen Proxy.

Ob es sich um einen statischen Proxy oder einen dynamischen Proxy handelt, das Zielobjekt (Ziel) muss eine Schnittstelle (Schnittstelle) implementieren. Beachten Sie, dass Sie diese nicht implementieren müssen, wenn Sie den von cglib bereitgestellten Proxy verwenden die Schnittstelle, aber verwenden Sie eine Unterklasse zur Implementierung, diese Methode wird vorerst nicht besprochen.

(1) Definieren Sie zunächst eine Schnittstelle

public interface IUserDao {
    void save();
}

(2) Definieren Sie das Zielobjekt (target)

public class UserDaoImpl implements IUserDao {
    public void save() {
        System.out.println("--------已经保存数据---------");
    }
}

(3) Definieren Sie das Proxy-Objekt #🎜 🎜#

public class UserDaoProxy implements IUserDao {
 private IUserDao target;//将目标对象放到代理对象中
 public UserDaoProxy(IUserDao target){
  this.target = target;
  }
 public void save() {
     System.out.println("------开始事务------");
            target.save();
     System.out.println("-------提交事务------");
    }
}

Testen Sie es:

public class Test {
public static void main(String[] args){
    IUserDao userDao = new UserDaoImpl();
    UserDaoProxy proxy = new UserDaoProxy(userDao);
    proxy.save();//通过代理对象调用save方法
    }
}

Das Ausgabeergebnis ist:

------Transaktion starten---- ---# 🎜🎜#--------Daten wurden gespeichert---------

-------Transaktion senden----- -

Ein Problem bei diesem Ansatz besteht darin, dass das Proxy-Objekt auch dieselbe Schnittstelle implementieren muss, die vom Proxy-Objekt implementiert wird, was zu einer ernsthaften Kopplung führt. Daher wird im Folgenden eine verbesserte Methode verwendet, nämlich der dynamische Proxy (JDK-Proxy).

Die dynamische Proxy-Methode erfordert außerdem, dass das Zielobjekt (Ziel) eine Schnittstelle implementiert

(1) Definieren Sie eine Schnittstelle (IUserDao)

( 2) Definition einer Zielobjektklasse (UserDaoImpl)

(3) Erstellen Sie eine dynamische Proxy-Klasse

public class ProxyFactory {
    //维护一个目标对象
    private Object target; 
    public ProxyFactory(Object target) {
        this.target = target;
    }
 
    //给目标对象生成代理对象
    public Object getProxyInstance() {
        System.out.println("----target class---" + target.getClass());
        System.out.println("----target interfaces---" +
            target.getClass().getInterfaces());
 
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                    System.out.println("----开始事务2-----");
 
                    //执行目标对象方法
                    Object returnValue = method.invoke(target, args);
                    System.out.println("----提交事务2----");
 
                    return returnValue;
                }
            });
    }
}

Testen Sie es:

public class Test {
    public static void main(String[] args) {
        //目标对象
        IUserDao target = new UserDao();
        System.out.println(target.getClass());
 
        //给目标对象创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println("----proxy----：" + proxy.getClass());
        proxy.save();
        proxy.delete();
    }
}

Ausgabeergebnis:

class com.jd.pattern.proxy.dynamicProxy.UserDao

----target class---class com.jd.pattern.proxy.dynamicProxy.UserDao# 🎜🎜#- ---target interfaces---[Ljava.lang.Class;@1fb3ebeb

----proxy----: class com.sun.proxy.$Proxy0
-- --Transaktion 2 starten-----
-----Speichern abgeschlossen------
----Transaktion 2 senden----
---- Transaktion 2 starten- ----
----Löschvorgang abgeschlossen----

----Transaktion 2 senden----

# 🎜🎜#zwei: Verwenden Sie einen dynamischen Proxy, um einen einfachen Interceptor zu implementieren.

Da ein dynamischer Proxy verwendet wird, muss es eine Schnittstelle, eine Zielklasse, eine Proxy-Klasse und einen Interceptor geben. 1. Definieren Sie eine Schnittstelle 🎜#

public interface BusinessFacade {
    void doSomething();
}

Testen Sie es:

public class BusinessClass implements BusinessFacade {
    public void doSomething() {
        System.out.println("在业务组件BusinessClass中调用doSomething方法");
    }
}

Ausgabeergebnis:

Call-Methode in InterceptorClass: before()

In Business Component Call die doSomething-Methode in BusinessClass

Rufen Sie die Methode in InterceptorClass auf: after()

Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine einfache Interceptor-Operation in Java über einen dynamischen Proxy. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!