代理模式去中心化

『壹』 分銷模式是怎樣的

分銷模式就是每一級分銷商均可以往下再發展分銷商。賺取兩類傭金，也即店鋪產品銷售傭金與店鋪推廣傭金。
1、關於銷售傭金：誰賣出誰拿銷售傭金，無論分銷商等級產品銷售傭金比例一致。
2、關於推廣傭金：每一個分銷商的下級分銷商賣出商品，上級分銷商可以拿到推廣傭金。

『貳』 代理的模式有幾種

一、代理商模式按數量分可分為三類：

1.獨家代理，

2.少頭博弈代理（2-3家），

3.多頭博弈代理（3家以上）。

選擇獨家代理或是非獨家代理，是中國企業首先要思考的。

二、按銷售商對代理商的滲透程度可分為兩類：

滲透類代理，獨立代理（非獨家代理）。

三、按代理商的級數可分為：單級代理商體制，多級代理商體制。

『叄』 代理銷售模式

好處：
1、不用投資產品在生產環節上的各項費用；
2、容易與其他代理商一起形成規模效應，使生產廠家降低經營成本，直接體現在降低產品價格上；
3、享受到廠家的各種資源，如品牌，培訓，制度，設備等；
4、市場風險減低，最直接就是降低產品存量風險；
5、退出容易。

缺點：
1、廠家有品牌的知識產權，最終體現在對下游的控制主動性；
2、信息不對稱，廠家的經營信息和經營規劃代理商完全不知道，但代理商的經營信息廠家完全掌握。這樣廠家可以隨時根據代理商的經營信息調整經營策略，規避風險或者轉嫁風險；
3、代理商既得利益不能保障，雖然國家規定產品質量問題由廠家承擔，但如果廠家失去承擔責任的能力或者逃避承擔責任，那麼作為流通環節最上游的代理商就可能會承擔法律和經濟責任。
4、資金風險，這個與信息不對稱有一定關聯，不過即使知道廠家經營信息，但代理商在合作期間要為廠家墊付一定的在途資金，這些資金的風險完全由代理商承擔。

好了，我的水平大概就只提供到這些了，老闆你就琢磨一下吧。

『肆』 代理模式 如何只在兩個方法里的一個方法加切面邏輯

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中被聲明，就可以被定義協議的類調用。這樣可以減少一個類暴露給外部的方法。
有利於程序的結構化與層次化。一個協議往往是解決問題的某個方法，對於一個其他的不過卻類似的問題，我們只用再次實現協議即可，避免了自己再次構思一組方法。協議的繼承機制使得這一有點更加強大。
說了怎麼多，總結起來只有一句：代理模式並不神秘，只是一個經過了優化的小技巧（讓某個類持有另一個類的指針）。代理和協議也只是讓程序耦合度更低，結構感更強而已。

『伍』 什麼原因讓招商代理模式無法持久下去

很多加盟商進來以後，不知道如何做市場拓展，而且在加盟前，沒有做過市場規劃，做好一個產品，需要是1計，2行，3總結。

『陸』 微商里總代一級二級代理怎麼回事

一級代理，就是總代理下面的員工，從總代理那裡拿貨，拿貨價要高一點。

二級代理，就是一級代理下面的員工，從一級代理那裡拿貨，拿貨價最高。

微商代理就是擁有產品授權，貨源可以直接從廠家拿，或者也可以自己尋找貨源。做微商代理可以發展下級代理，把貨發給下家賺差價，自己也可以拿來賣。

(6)代理模式去中心化擴展閱讀：

微商代理的級別：

一般常見的是五個級別。最高代理級別進行隱藏，對公布常見四個級別。比如聯合創始人、總代理、一級代理商、特約代理商，這是我們常見的微商代理制度。聯合創始人，作為對外公開的最高級別的代理級別。

一般來說，在聯合創始人上面還有一層隱藏的微商代理級別。隱藏的代理級別主要有兩點作用，第一點作用是，在微商起盤前期，30至50人的項目種子發起人代理級別的代理商。這30至50人的種子代理商，主要任務是發展招募聯合創始人。

一般來說這30人和微商項目的負責人都具有較強的社交關系。第二點，用於品牌方與微商團隊的合作，團隊負責人給與最高級別代理待遇。

當然市面上也常見五個代理級別，比如聯合創始人，總代、一級代理商、二級代理商、特約代理商。這種五級代理商，聯創的上面肯定還有一集最高隱藏代理級別，也就說是六級，這種六級制度適用於利潤空間比較大的產品。

除了這兩種代理制度外，還有一種代理模式，分為上三級和下四級的代理模式。何為三級、下四級代理模式呢?一般來說下四級就如同我們常見到的代理級別。

主要用於個人微商的招商，微商主體為個人，一次性拿貨金額較少。上三級代理層級用於成型的微商團隊，個體企業和分公司類型的微商形式的招募。

『柒』 java策略模式和代理模式有什麼區別

這2者 根本就不能 談什麼區別。。。
完全不是一回事

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

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

『捌』 Java代理的三種模式有什麼

Java的三種代理模式簡述

本文著重講述三種代理模式在java代碼中如何寫出，為保證文章的針對性，暫且不討論底層實現原理，具體的原理將在下一篇文章中講述。

代理模式是什麼

代理模式是一種設計模式，簡單說即是在不改變源碼的情況下，實現對目標對象的功能擴展。

比如有個歌手對象叫Singer，這個對象有一個唱歌方法叫sing()。

假如你希望，通過你的某種方式生產出來的歌手對象，在唱歌前後還要想觀眾問好和答謝，也即對目標對象Singer的sing方法進行功能擴展。

但是往往你又不能直接對源代碼進行修改，可能是你希望原來的對象還保持原來的樣子，又或許你提供的只是一個可插拔的插件，甚至你有可能都不知道你要對哪個目標對象進行擴展。這時就需要用到java的代理模式了。網上好多用生活中的經理人的例子來解釋「代理」，看似通俗易懂，但我覺得不適合程序員去理解。程序員應該從代碼的本質入手。

『玖』 java中的代理模式一般和什麼模式相結合

Java編程的目標是實現現實不能完成的，優化現實能夠完成的，是一種虛擬技術。生活中的方方面面都可以虛擬到代碼中。代理模式所講的就是現實生活中的這么一個概念：中介。
代理模式的定義：給某一個對象提供一個代理，並由代理對象控制對原對象的引用。
代理模式包含如下角色：
ISubject：抽象主題角色，是一個介面。該介面是對象和它的代理共用的介面。
RealSubject：真實主題角色，是實現抽象主題介面的類。
Proxy：代理角色，內部含有對真實對象RealSubject的引用，從而可以操作真實對象。代理對象提供與真實對象相同的介面，以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。
實現動態代理的關鍵技術是反射。
靜態代理
代理模式有幾種，虛擬代理，計數代理，遠程代理，動態代理。主要分為兩類，靜態代理和動態代理。靜態代理比較簡單，是由程序員編寫的代理類，並在程序運行前就編譯好的，而不是由程序動態產生代理類，這就是所謂的靜態。
考慮這樣的場景，管理員在網站上執行操作，在生成操作結果的同時需要記錄操作日誌，這是很常見的。此時就可以使用代理模式，代理模式可以通過聚合和繼承兩種方式實現：
<pre name="code" class="java">/**方式一：聚合式靜態代理 * @author Goser (mailto:[email protected]) * @Since 2016年9月7日 */ //1.抽象主題介面 public interface Manager { void doSomething(); } //2.真實主題類 public class Admin implements Manager { public void doSomething() { System.out.println("Admin do something."); } } //3.以聚合方式實現的代理主題 public class AdminPoly implements Manager{ private Admin admin; public AdminPoly(Admin admin) { super(); this.admin = admin; } public void doSomething() { System.out.println("Log:admin操作開始"); admin.doSomething(); System.out.println("Log:admin操作結束"); } } //4.測試代碼 Admin admin = new Admin(); Manager m = new AdminPoly(admin); m.doSomething(); //方式二：繼承式靜態代理 //與上面的方式僅代理類和測試代碼不同 //1.代理類 public class AdminProxy extends Admin { @Override public void doSomething() { System.out.println("Log:admin操作開始"); super.doSomething(); System.out.println("Log:admin操作開始"); } } //2.測試代碼 AdminProxy proxy = new AdminProxy(); proxy.doSomething();</pre>
聚合實現方式中代理類聚合了被代理類，且代理類及被代理類都實現了同一個介面，可實現靈活多變。繼承式的實現方式則不夠靈活。
比如，在管理員操作的同時需要進行許可權的處理，操作內容的日誌記錄，操作後數據的變化三個功能。三個功能的排列組合有6種，也就是說使用繼承要編寫6個繼承了Admin的代理類，而使用聚合，僅需要針對許可權的處理、日誌記錄和數據變化三個功能編寫代理類，在業務邏輯中根據具體需求改變代碼順序即可。
動態代理
一般來說，對代理模式而言，一個主題類與一個代理類一一對應，這也是靜態代理模式的特點。
但是，也存在這樣的情況，有n各主題類，但是代理類中的「前處理、後處理」都是一樣的，僅調用主題不同。也就是說，多個主題類對應一個代理類，共享「前處理，後處理」功能，動態調用所需主題，大大減小了程序規模，這就是動態代理模式的特點。
JDK動態代理
實現
<pre name="code" class="java">//1. 抽象主題 public interface Moveable { void move() throws Exception; } //2. 真實主題 public class Car implements Moveable { public void move() throws Exception { Thread.sleep(new Random().nextInt(1000)); System.out.println("汽車行駛中…"); } } //3.事務處理器 public class TimeHandler implements InvocationHandler { private Object target; public TimeHandler(Object target) { super(); this.target = target; } /** * 參數： *proxy 被代理的對象 *method 被代理對象的方法 *args 方法的參數 * 返回： *Object 方法返回值 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { long startTime = System.currentTimeMillis(); System.out.println("汽車開始行駛…"); method.invoke(target, args); long stopTime = System.currentTimeMillis(); System.out.println("汽車結束行駛…汽車行駛時間：" + (stopTime - startTime) + "毫秒！"); return null; } } //測試類 public class Test { public static void main(String[] args) throws Exception{ Car car = new Car(); InvocationHandler h = new TimeHandler(car); Class<?> cls = car.getClass(); /** *loader 類載入器 *interfaces 實現介面 *h InvocationHandler */ Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h); m.move(); } }</pre>
代碼講解：
在測試代碼中，Proxy.newProxyInstance()方法需要3個參數：類載入器（要進行代理的類）、被代理類實現的介面，事務處理器。所以先實例化Car，實例化InvocationHandler的子類TimeHandler，將各參數傳入Proxy的靜態方法newProxyInstance()即可獲得Car的代理類，前面的靜態代理，代理類是我們編寫好的，而動態代理則不需要我們去編寫代理類，是在程序中動態生成的。
JDK動態代理步驟
1. 創建一個實現InvocationHandler介面的類，它必須實現invoke()方法
2. 創建被代理的類及介面
3. 調用Proxy的靜態方法，創建一個代理類
4. 通過代理調用方法
而為什麼要進行如此操作，可以從Proxy和InvocationHandler的源碼中找打答案。對源碼不感興趣的可以將下面的源碼部分小節略過。
JDK動態代理原理與源碼
ewProxyInstance()方法的源碼：
<pre name="code" class="java"> public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException{ if (h == null) { throw new NullPointerException(); } final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /*查找或生成指定的代理類*/ Class<?> cl = getProxyClass0(loader, intfs); /*用指定的調用處理程序調用它的構造函數.*/ try { //獲得類的構造函數 final Constructor<?> cons =cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) { //當需要代理的類實現了一個非public的介面時，因為這樣的介面需要特殊的許可權，因此調用doPrivilege（native 修飾的方法）創建代理實例。 return AccessController.doPrivileged(newPrivilegedAction<Object>() { public Object run() { return newInstance(cons,ih); } }); } else { return newInstance(cons,ih); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } }</pre>
可以看到，獲得代理類的代碼是
Class<?>cl = getProxyClass0(loader,intfs)
並由此獲得代理類的構造函數，生成代理類的實例返回給該方法的調用者。
繼續跟進getProxyClass0()方法：
<pre name="code" class="java">/** 生成代理類。調用該方法前必須使用checkproxyaccess方法執行許可權檢查。*/ private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { //檢查實現的介面數，65535這個數字好特殊，埠數好像也是這個，這個數字是由虛擬機所決定的，2^16-1個 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // 如果代理類已經通過實現給定介面的類載入器創建了，則返回緩存中的該類的副本；否則將通過ProxyClassFactory創建代理類 return proxyClassCache.get(loader, interfaces); }</pre>
還是沒有看到代理類是怎麼生成的，只知道代理類是從
roxyClassCache
中取得的，這個變數是與緩存相關的一個對象，查看該變數的聲明與初始化：
<pre name="code" class="java">private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());</pre>
可以發現
roxyClassCache
是個用來緩存代理類的類變數，大家知道類變數的特點是與類一一對應，在一個虛擬機中類只有一個，對應著在一個虛擬機中類變數也只有一個，且在此處，在Proxy類被載入的時候就賦值了。在賦值操作的參數中有ProxyClassFactory()這么一個構造函數，這個是動態代理中的關鍵：生成代理類的類文件位元組碼。繼續跟進去，找到代理類的生成之處了：
<pre name="code" class="java"> /** 根據給定的類載入器和介面數組生成代理類的工廠類*/ private static final class ProxyClassFactory implements BiFunction<ClassLoader,Class<?>[], Class<?>> { // 所有代理類名稱的前綴 private static final String proxyClassNamePrefix = "$Proxy"; //用於生成唯一代理類名稱的下一個序號 private static final AtomicLong nextUniqueNumber = new AtomicLong(); @Override public Class<?> apply(ClassLoader loader,Class<?>[] interfaces) { Map<Class<?>, Boolean>interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<?> intf : interfaces) { /* 驗證類載入器將此介面的名稱解析為實際對象的名稱。*/ Class<?> interfaceClass =null; try { interfaceClass = Class.forName(intf.getName(),false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from classloader"); } /* 驗證類對象確實是一個介面。*/ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /*確保介面唯一*/ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } String proxyPkg = null; // 代理類的包名 /*記錄非公開代理介面的包，以便將代理類定義在同一個包中。確認所有非公共代理介面都在同一個包中。*/ for (Class<?> intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { String name =intf.getName(); int n = name.lastIndexOf('.'); String pkg = ((n == -1) ? "" : name.substring(0, n + 1)); if (proxyPkg == null) { proxyPkg = pkg; } else if (!pkg.equals(proxyPkg)) { throw new IllegalArgumentException( "non-public interfaces fromdifferent packages"); } } } if (proxyPkg == null) { // 如果沒有非公開的代理介面，使用com.sun.proxy作為包名 proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; } /* 生成代理類名的序號*/ long num = nextUniqueNumber.getAndIncrement(); //生成全類名 String proxyName = proxyPkg + proxyClassNamePrefix + num; /*生成代理類位元組碼 */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces); try { return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString()); } } }</pre>
ProxyClassFactory
中，可以看到產生代理類的具體邏輯，大致上是，根據傳遞的被代理類及其實現的介面生成代理類的位元組碼載入到緩存中，但是載入到緩存中只是一個.java文件也不能用，所以底層還有編譯等操作。到這里，可以大致的看清JDK中動態代理的面孔了，實現的步驟為：
1. 創建代理類的源碼；
2. 對源碼進行編譯成位元組碼；
3. 將位元組碼載入到內存；
4. 實例化代理類對象並返回給調用者；
底層的代碼我們看不到，但是我們可以查看其生成的位元組碼：
<pre name="code" class="java">//獲得位元組碼的測試方法 byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy1", Car.class.getInterfaces()); FileOutputStream out = null; try { out = new FileOutputStream(System.getProperty("user.dir") + "\\$Proxy1.class"); out.write(classFile); out.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } } //生成的位元組碼： importcn.com.goser.proxy.imooc.staticproxy.Moveable; importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Method; importjava.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class $Proxy1 extends Proxy implements Moveable { private static Method m1; private static Method m3; private static Method m0; private static Method m2; public $Proxy1(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } public final void move() throws Exception { try { this.h.invoke(this, m3, null); return; } catch (Exception localException) { throw localException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } public final int hashCode() throws { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } public final String toString() throws { try { return (String)this.h.invoke(this, m2, null); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("cn.com.goser.proxy.imooc.staticproxy.Moveable").getMethod("move", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); return; } catch () { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch () { } throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } }</pre>
生成的位元組碼比較長，但是在位元組碼中最關鍵的信息是代理類的聲明：
ublic final class $Proxy1 extends Proxy
可以看到生成的代理類是繼承了Proxy類的，這就是說明了為什麼使用JDK動態代理不能實現繼承式動態代理，原因是Java不允許多繼承，而生成的代理類本身就已經繼承了Proxy類。
至此，JDK的動態代理的使用及底層原理分析完畢，揭下動態代理的神秘面紗，果然是枚美女。
至於最底層的native方法是怎麼動態生成代理類的位元組碼我們也可以簡單的模擬一下，先分析下模擬的步驟：首先要生成一段代理類的源碼，然後將源碼編譯後生成代理類的實例返回給調用者。依據此步驟開始編寫我們的模擬代碼：
<pre name="code" class="java">/** * JDK java.lang.reflect.Proxy的模擬 * @author Goser (mailto:[email protected]) * @Since 2016年9月7日 */ public class Proxy { private static final String RT = "\r\n"; public static Object newProxyInstance() throws Exception{ //聲明一段源碼 String sourceCode = "packagecn.com.goser.proxy.jdk.simulate;"+ RT + "importcn.com.goser.proxy.imooc.staticproxy.Admin;" + RT + "importcn.com.goser.proxy.imooc.staticproxy.Manager;" + RT + "//以聚合方式實現的代理主題" + RT + "public class $Proxy0 implementsManager{" + RT + " privateAdmin admin;" + RT + " public$Proxy0(Admin admin) {" + RT + " super();" + RT + " this.admin= admin;" + RT + " }" + RT + " publicvoid doSomething() {" + RT + " System.out.println(\"Log:admin操作開始\");" + RT + " admin.doSomething();" + RT + " System.out.println(\"Log:admin操作結束\");" + RT + " }" + RT + "}"; String filename = System.getProperty("user.dir") + "/src/main/java/cn/com/goser/proxy/jdk/simulate/$Proxy0.java"; File file = new File(filename); //使用org.apache.commons.io.FileUtils.writeStringToFile()將源碼寫入磁碟 //編寫到處，可以運行一下程序，可以在當前目錄中看到生成的.java文件 FileUtils.writeStringToFile(file,sourceCode); //獲得當前系統中的編譯器 JavaCompiler complier = ToolProvider.getSystemJavaCompiler(); //獲得文件管理者 StandardJavaFileManager fileMgr =complier.getStandardFileManager(null, null, null); Iterable its =fileMgr.getJavaFileObjects(filename); //編譯任務 CompilationTask task = complier.getTask(null, fileMgr, null, null, null, its); //開始編譯，執行完可在當前目錄下看到.class文件 task.call(); fileMgr.close(); //load到內存 ClassLoader loader = ClassLoader.getSystemClassLoader(); Class cls = loader.loadClass("cn.com.goser.proxy.jdk.simulate.$Proxy0"); //生成代理類對象 Constructor ct = cls.getConstructor(Admin.class); return ct.newInstance(new Admin()); } } class test{ public static void main(String[] args) throws Exception { Manager m = (Manager)Proxy.newProxyInstance(); m.doSomething(); } }</pre>
運行測試代碼，結果和手工編寫的結果一致，完成了JDK中動態代理的實現模擬。
cglib動態代理
前面分析到，因為Java只允許單繼承，而JDK生成的代理類本身就繼承了Proxy類，因此，使用JDK實現的動態代理不能完成繼承式的動態代理，但是我們可以使用cglib來實現繼承式的動態代理。
大名鼎鼎的Spring中就含有cglib動態代理，在此也以Spring中自帶的cglib完成動態代理的實現：
<pre name="code" class="java">//1.具體主題 public class Train{ public void move(){ System.out.println("火車行駛中…"); } } //2.生成代理 public class CGLibProxy implements MethodInterceptor { private Enhancer enhancer = new Enhancer(); public Object getProxy(Class<?> clazz){ enhancer.setSuperclass(clazz); enhancer.setCallback(this); return enhancer.create(); } /** * 攔截所有目標類方法的調用 * 參數： * obj目標實例對象 *method 目標方法的反射對象 * args方法的參數 * proxy代理類的實例 */ public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { //代理類調用父類的方法 System.out.println("日誌開始"); proxy.invokeSuper(obj, args); System.out.println("日誌結束"); return null; } } //3.測試 public class Test { public static void main(String[] args) { CGLibProxy proxy = new CGLibProxy(); Train t = (Train) proxy.getProxy(Train.class); t.move(); } }</pre>

『拾』 分銷模式與傳統營銷模式有什麼不同之處

一、傳統的分銷模式

1、工作量

它是通過登門入戶拜訪、或者是掃馬路的形式，來做自己的營銷推廣。但分銷模式工作量大，工作效率低，銷售覆蓋面窄。

2、傳統的經銷代理模式

它是渠道功能的重要承擔者，中間商是可以全部或部分參與分銷渠道的實際物流、促銷流、市場信息流等。一般來說，分銷渠道所具有的實現產品價值及提高交易效率和效益的功能是增強企業競爭優勢的功能，中間商環節多，從面導致營銷渠道時間過長。生產商也無法與Z終用戶直接聯系，從而增加了客戶的經營成本。

3、傳統的廣告終端模式

廣告發布的形式與內容多，報紙媒體的軟文模式、廣播電台的電台講座模式、電視的專題片模式。可是這種投入費用高，回款慢，經營風險也較大。

4、傳統的電話銷售模式

通過電話銷售產品和宣傳公司業務，通過電話與客戶進行有效溝通了解客戶需求，尋求銷售機會並完成銷售業績。但是它工作量大，工作效率低，客戶無法直觀了解產品，而導致客戶信賴度低。

二、網路營銷作為一種全新的營銷方式。

1、網路媒介是具有傳播范圍廣、速度快、沒有時間地域限制、也沒有時間版面約束、內容詳盡、多媒體傳送、形象生動、雙向交流、反饋迅速等特點，它是有利於提高企業營銷信息傳播的效率，從面增強企業營銷信息傳播的效果，降低企業營銷信息傳播的成本。

2、網路營銷沒有店面租金成本。且有實現產品直銷，能幫助企業減輕庫存壓力，降低經營成本的營銷手段。

3、網路營銷任何企業都不受自身規模的絕對限制，它能平等地獲取世界各地的信息及平等地展示自己，利用網路營銷，各企業也只需花極少的成本，就可以迅速建立起自己的全球信息網和貿易網，將自身產品的信息迅速傳遞到各個市場。

4、網路營銷能使消費者擁有比傳統營銷更大的選擇自由。消費者也可以根據自己的特點和需求在全球范圍內不受地域、時間限制，快速尋找自己的產品，並能進行充分的比較，有利於節省消費者的交易時間與交易成本。此外，網路營銷還可以幫助企業實現與消費者的一對一溝通，便於企業針對消費者的個別需要，提供一對一的個性化服務。

網路營銷作為傳統營銷的延伸與發展，它既有與傳統營銷共性的一面，也有區別於傳統營銷的一面。搜到網認為隨著互聯網的飛速發展網路營銷的其特點也表現得越來越突出。