java代理模式,java代理模式有幾種

本文目錄一覽：

• 1、java動態代理是什麼
• 2、什麼是java代理模式，具體相關的動態代理和靜態代理分別是什麼？舉例更好啦~
• 3、Java 代理模式和裝飾者模式的區別
• 4、java的代理模式有何用，直接調用用實現類不就行了嗎，幹嘛多此一舉呢。。。。
• 5、java策略模式和代理模式有什麼區別？

java動態代理是什麼

import java.lang.reflect.Proxy;

A． 創建一個實現接口InvocationHandler的類，他必須實現invoke方法

B． 創建被代理的類以及接口。

C． 通過Proxy的靜態方法newProxyInstance（ClassLoader loader，Class【】interfaces，InvocationHandler handler）創建一個代理

D． 通過代理調用方法。

java動態代理：是在運行是生成的class對象，在生成時必須提供一組或一個interface給它，然後該class就宣稱它實現了這些interface。你當然可以把該class的實例當做這些interface中的任何一個來用，當然，這個DynamicProxy其實就是一個Proxy，他不會替你做實質性的工作，在生成它的實例時你必須提供一個handler，由它接管實際的工作。因此，DynamicProxy必須實現InvocationHandler接口。

5） 一個動態代理了和一個InvocationHandler 實現關聯的。每一個動態代理實例的調用都要通過InvocationHandler接口的handler（調用處理器）來調用，動態代理不做任何執行操作，只是在創建動態代理時，把要實現的接口和handler關聯，動態代理要幫助被代理執行的任務，要轉交給handler來執行。其實就是調用invoke方法。

什麼是java代理模式，具體相關的動態代理和靜態代理分別是什麼？舉例更好啦~

簡單的例子: HelloSpeaker.java

import java.util.logging.*;

public class HelloSpeaker {

private Logger logger = Logger.getLogger(this.getClass().getName());

public void hello(String name) {

logger.log(Level.INFO, “hello method starts….”); //日誌記錄

System.out.println(“Hello, ” + name); //!!!!!!!!!!!

logger.log(Level.INFO, “hello method ends….”); //日誌記錄

}

}

HelloSpeaker在執行hello()方法時，我們希望能記錄該方法已經執行以及結束，

最簡單的作法就是如上在執行的前後加上記錄動作，然而Logger介入了HelloSpeaker中，

記錄這個動作並不屬於HelloSpeaker，這使得HelloSpeaker的職責加重。

——————————————————————————————

怎麼辦，用下面的方法或許好一些:

先定義一個接口:

public interface IHello {

public void hello(String name);

}

——————————————————————————————

實現該接口

public class HelloSpeaker implements IHello {

public void hello(String name) {

System.out.println(“Hello, ” + name);

}

}

public class Greeting implements IHello{

public void hello(String name){

System.out.println(“Greeting, ” + name);

}

}

——————————————————————————————

實現一個代理對象: HelloProxy

import java.util.logging.*;

public class HelloProxy implements IHello {

private Logger logger = Logger.getLogger(this.getClass().getName());

private IHello helloObject; //被代理對象

public HelloProxy(){}

public HelloProxy(IHello helloObject) {

this.helloObject = helloObject; //把被代理對象傳入

}

public void setHelloObject(IHello helloObject){

this.helloObject = helloObject;

}

public IHello getHelloObject(){

return this.helloObject;

}

public void hello(String name) {

logger.log(Level.INFO, “hello method starts….”); //日誌記錄

helloObject.hello(name); //!!!!!!!!調用被代理對象的方法

logger.log(Level.INFO, “hello method ends….”); //日誌記錄

}

}

—————————————————————————————————–

執行:

IHello helloProxy = new HelloProxy(new HelloSpeaker()); //生成代理對象, 並給它傳入一個被代理的對象

helloProxy.hello(“world”);

//IHello h=factory.getBean(“hello”); // IoC

//h.hello(“world”);

IHello helloProxy = new HelloProxy(new Greeting()); //生成代理對象, 並給它傳入一個被代理的對象

helloProxy.hello(“world”);

—————————————————————————————————–

代理對象HelloProxy將代理真正的HelloSpeaker來執行hello()，並在其前後加上記錄的動作，

這使得我們的HelloSpeaker在寫時不必介入記錄動作，HelloSpeaker可以專心於它的職責。

這是靜態代理的基本範例，然而，代理對象的一個接口只服務於一種類的對象，而且如果要代理的方法很多，

我們勢必要為每個方法進行代理，靜態代理在程序規模稍大時就必定無法勝任.

Java在JDK 1.3之後加入協助開發動態代理功能的類，我們不必為特定對象與方法寫特定的代理，使用動態代理，

可以使得一個handler服務於各個對象，首先，一個handler必須實現java.lang.reflect.InvocationHandler：

import java.util.logging.*;

import java.lang.reflect.*;

public class LogHandler implements InvocationHandler { //

private Logger logger = Logger.getLogger(this.getClass().getName());

private Object delegate; //被代理的對象

public Object bind(Object delegate) { //自定義的一個方法，用來綁定被代理對象的，返回值為被代理方法的返回值

this.delegate = delegate;

return Proxy.newProxyInstance(

delegate.getClass().getClassLoader(),

delegate.getClass().getInterfaces(),

this); //通過被代理的對象生成它的代理對象, 並同handler綁定在一起

}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

Object result = null;

try {

logger.log(Level.INFO, “method starts…” + method); //日誌記錄

result = method.invoke(delegate, args); //!!!!!!!!調用被代理對象的方法

logger.log(Level.INFO, “method ends…” + method); //日誌記錄

} catch (Exception e){

logger.log(Level.INFO, e.toString());

}

return result;

}

}

InvocationHandler的invoke()方法會傳入被代理對象的方法名稱與參數, 實際上要執行的方法交由method.invoke()，

並在其前後加上記錄動作，method.invoke()返回的對象是實際方法執行過後的回傳結果。

動態代理必須有接口:

public interface IHello {

public void hello(String name);

}

實現該接口:

public class HelloSpeaker implements IHello {

public void hello(String name) {

System.out.println(“Hello, ” + name);

}

}

執行:

LogHandler logHandler = new LogHandler();

IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker()); //傳入被代理對象, 傳回代理對象

helloProxy.hello(“Justin”);

Java 代理模式和裝飾者模式的區別

您好！

代理模式與裝飾者模式看起來很像，都實現基礎對象實現的接口，在其自身對象中都保存着對被代理/被裝飾者的對象引用。

先來看看裝飾者模式的定義：動態的將責任附加到被裝飾者對象上，用於擴展對象的功能。比繼承的靈活性大。典型的如Java IO的設計即是裝飾者模式的典型應用。

代理模式模式的定義：對其他對象進行代理，以控制對被代理對象的訪問。Spring的為業務邏輯層方法生成的代理類，主要進行一些事務控制等。

由定義可以看出裝飾的責任是擴展功能 ，而代理主要控制訪問。

具體例子可參看Java IO裝飾/Spring的動態代理/Hibernate的代理等。

望採納

java的代理模式有何用，直接調用用實現類不就行了嗎，幹嘛多此一舉呢。。。。

使用代理類可以在實現類的基礎上進行擴展，可以在方法中動態加入代碼。這裡要理解的是，實現類和代理類都是繼承了同一個接口的(必須的)舉個例子，如果你要通過一個實現類，將文本控件中輸入的數字，做 加減乘除(也許還有很多運算) 法的運算，你發現這樣會有一些問題存在，字符串如果不能轉換成數字，就會報錯。那麼，你必須在方法的開頭加入驗證判斷。但是，你又發現每個方法都要寫驗證是很麻煩的，而且代碼量也會很多。於是你將驗證抽取出來，成為一個方法。 每個運算方法都在開頭調用這個驗證就行了。這樣是沒有問題的。然而，如果這個實現類不是你寫的，是A程序員寫的，而A程序員覺得他無法知道，使用這個實現類的程序員是否希望驗證這個字符串，所以，他把字符串的驗證工作交給了調用的程序員。而你在使用這個實現類的時候，你不能修改這個實現類，給他的每個方法開頭加入字符串的驗證。那麼怎麼去讓這個實現類的每個運算方法都在調用前都去驗證一下呢？代理就可以動態的在每個方法前加入驗證，比如add(int，int)方法，如果調用代理類的方法，代理類將先做驗證，然後再去調用實現類的方法。這個是有必要的，因為代理的動態的加入驗證代碼，不需要每個方法錢都加入驗證。最後總結一下，代理的作用大多是實現類的實現，對於調用者特定功能來說，做的還不夠，這代理，可以加入那些還不夠的代碼，然後再去調用實現類。

java策略模式和代理模式有什麼區別？

這2者 根本就不能 談什麼區別。。。

完全不是一回事

策略模式：

多個類只區別在表現行為不同，可以使用Strategy模式，在運行時動態選擇具體要執行的行為。

代理模式

對其他對象提供一種代理以控制對這個對象的訪問。