靜態代理java

1. java靜態代理與動態代理的區別

JAVA的靜態代理與動態代理比較
1.靜態代理類：
由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。動態代理類：在程序運行時，運用反射機制動態創建而成。
由此可見，代理類可以為委託類預處理消息、把消息轉發給委託類和事後處理消息等。
常式1 HelloService.java
package proxy;
import java.util.Date;
public interface HelloService{
public String echo(String msg);
public Date getTime();
}
2.動態代理類
與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟體系統的可擴展性，因為Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

Proxy類提供了創建動態代理類及其實例的靜態方法。
（1）getProxyClass()靜態方法負責創建動態代理類，它的完整定義如下：
public static Class<?> getProxyClass(ClassLoader loader, Class<?>[] interfaces) throws IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面。
（2）newProxyInstance()靜態方法負責創建動態代理類的實例，它的完整定義如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws
IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面，參數handler 指定與動態代理類關聯的 InvocationHandler 對象。
以下兩種方式都創建了實現Foo介面的動態代理類的實例：
/**** 方式一 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//創建動態代理類
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });
//創建動態代理類的實例
Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
/**** 方式二 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//直接創建動態代理類的實例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);
由Proxy類的靜態方法創建的動態代理類具有以下特點：
動態代理類是public、final和非抽象類型的；
動態代理類繼承了java.lang.reflect.Proxy類；
動態代理類的名字以「$Proxy」開頭；
動態代理類實現getProxyClass()和newProxyInstance()方法中參數interfaces指定的所有介面；

2. 靜態代理，JDK動態代理和CGLib動態代理之前的區別

區別：
java動態代理是利用反射機制生成一個實現代理介面的匿名類，在調用具體方法前調用InvokeHandler來處理。而cglib動態代理是利用asm開源包，對代理對象類的class文件載入進來，通過修改其位元組碼生成子類來處理。
1、如果目標對象實現了介面，默認情況下會採用JDK的動態代理實現AOP
2、如果目標對象實現了介面，可以強制使用CGLIB實現AOP
3、如果目標對象沒有實現了介面，必須採用CGLIB庫，spring會自動在JDK動態代理和CGLIB之間轉換

3. 什麼是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");

4. Java動態代理和靜態代理的區別

缺Java中的動態代理相對於靜態代理優點:
1、靜態代理類和委託類實現了相同的介面，代理類通過委託類實現了相同的方法。這樣就出現了大量的代碼重復。如果介面增加一個方法，除了所有實現類需要實現這個方法外，所有代理類也需要實現此方法。增加了代碼維護的復雜度。
2、靜態代理對象只服務於一種類型的對象，如果要服務多類型的對象。勢必要為每一種對象都進行代理，靜態代理在程序規模稍大時就無法勝任了。如上的代碼是只為UserManager類的訪問提供了代理，但是如果還要為其他類如Department類提供代理的話，就需要我們再次添加代理Department的代理類。

5. java靜態代理和裝飾模式的區別

1. 裝飾模式：以對客戶端透明的方式擴展對象的功能，是繼承關系的一個替代方案；
   

2. 代理模式：給一個對象提供一個代理對象，並有代理對象來控制對原有對象的引用；

3. 裝飾模式應該為所裝飾的對象增強功能；代理模式對代理的對象施加控制，並不提供對象本身的增強功能

4. 二者的實現機制確實是一樣的，可以看到他們的實例代碼重復是很多的。但就語義上說，這兩者的功能是相反的，模式的一個重要作用是簡化其他程序員對你程序的理解，你在一個地方寫裝飾，大家就知道這是在增加功能，你寫代理，大家就知道是在限制。

6. java有幾個學習方向

java作為計算機編程使用最多的語言之一，就業面是比較廣的，是一個不錯的選擇。

作為世界上最通用的編程語言之一，Java現在幾乎在平台、技術和經濟領域都得到了廣泛的應用。這就是為什麼對Java開發人員的需求不斷增加的原因。基本上每一家專業的IT培訓學校，都會開設有Java方向的課程。這里簡單列舉下學習Java要學習的內容。

Java的學習內容：

①Java編程基礎

②web前端開發技術（MySQL資料庫、HTML5、CSS3、JS、linux系統）

③後台開發主流的技術框架（SSM框架、SSH框架）

④前後端分離的開發模式（GitHub、Maven）

⑤分布式微服架構技術以及SpringCloud等技術（Dubbox的微服實戰、Spring Cloud的微服實戰、Nosql資料庫、Vue.js實戰等）

互聯網行業目前還是最熱門的行業之一，學習IT技能之後足夠優秀是有機會進入騰訊、阿里、網易等互聯網大廠高薪就業的，發展前景非常好，普通人也可以學習。

想要系統學習，你可以考察對比一下開設有相關專業的熱門學校，好的學校擁有根據當下企業需求自主研發課程的能力，能夠在校期間取得大專或本科學歷，中博軟體學院、南京課工場、南京北大青鳥等開設相關專業的學校都是不錯的，建議實地考察對比一下。

祝你學有所成，望採納。

7. Java靜態代理和iOS代理模式這兩個概念的理解上的疑惑

java靜態代理模式,舉例給你，看下如何理解：
public class Ts {
public static void main(String[] args) throws Exception {
// 通過中介公司生產一批衣服
ClothingProct cp = new ProxCompany( new LiNingCompany());
cp.proctClothing();
}

}

/**
* 定義生產一批衣服功能的介面
*
*/
interface ClothingProct {

void proctClothing(); // 有生產一批衣服的功能

}

/**
*
* 代理類：中介公司
*
*/
class ProxCompany implements ClothingProct {

private ClothingProct cp ; // 中介公司不會生產衣服，需要找一家真正能生產衣服的公司

ProxCompany(ClothingProct cp) {
super ();
this . cp = cp;
}

@Override
public void proctClothing() {

System. out .println( "收取1塊錢的中介費" );
cp .proctClothing();

}

}

/**
*
* 李寧公司是生產服裝的目標類
*
*/
class LiNingCompany implements ClothingProct {

@Override
public void proctClothing() {

System. out .println( "生產一批衣服。。。。" );
}

}

上面程序的做法，使用的模式是靜態代理模式

靜態代理模式在現實編程中的弊端：
它的特徵是代理類和目標對象的類都是在編譯期間確定下來的，不利於程序上的擴展，上面示例中，如果客戶還想找一個「生產一批鞋子」的工廠，那麼還需要新增加一個代理類和一個目標類。如果客戶還需要很多其他的服務，就必須一一的添加代理類和目標類。那就需要寫很多的代理類和目標類

代理模式到底做了什麼？
我眼中的代理模式只有兩個關注點：協議和代理者
協議定義了一組方法，由某一個類負責實現。
代理者作為某個類的一個屬性，通常是另一個類的實例對象，可以負責完成原來這個類不方便或者無法完成的任務。
首先談一談代理者，在腦中重新回想一下代理模式的實現過程。在頁面B中定義一個代理對象的時候，好像和定義一個普通的property非常類似（除了 weak和id《delegate》>）。這也正是我對代理的概括：代理本來就是一個屬性而已，並沒有非常神秘。
當然，代理者並不只是一個類普通的屬性，否則我只需要重寫一下B的初始化方法即可達到同樣的效果：
self.BVC = [[BViewController alloc]initWithDelegate:self];

然後在BViewController.m中定義一個AViewController *AVC並在初始化方法中賦值即可。
注意到代理者在定義的時候，格式往往是這樣的：
id <SomeDelegate> delegate;

所以我對代理的優勢的理解是：
代理的核心優勢在於解耦
與直接聲明一個屬於某個固定的類的代理者相比，聲明為id的代理者具備兩個明星的優勢。
允許多個不同的類成為本類的代理。試想一下在本文例子中，如果頁面B可以跳轉回N個頁面，如果還是通過聲明一個普通對象的方式，那怎麼辦？
允許代理者的類還不固定。試想一下，UITableView也有delegate，它根本不知道那個類會成為它的代理者。
再看一看協議。協議更加簡單了。協議只是定義了一組方法。在代理模式中，完全可以不用在頁面B中定義一個協議，然後A再去遵循這個協議。直接調用A的方法即可。
個人認為協議的優點在於以下幾點：
可以利用Xcode的檢查機制。對於定義為@required的方法，如果實現了協議而沒有實現這個方法，編譯器將會有警告。這樣可以防止因為疏忽，忘記實現某個代碼的情況，而由於OC的運行時特性，這樣的錯誤往往在運行階段才會導致程序崩潰。
有利於代碼的封裝。如果一個類，實現了某個協議，那麼這個協議中的方法不必在.h中被聲明，就可以被定義協議的類調用。這樣可以減少一個類暴露給外部的方法。
有利於程序的結構化與層次化。一個協議往往是解決問題的某個方法，對於一個其他的不過卻類似的問題，我們只用再次實現協議即可，避免了自己再次構思一組方法。協議的繼承機制使得這一有點更加強大。
說了怎麼多，總結起來只有一句：代理模式並不神秘，只是一個經過了優化的小技巧（讓某個類持有另一個類的指針）。代理和協議也只是讓程序耦合度更低，結構感更強而已。