代理模式去中心化

『壹』 分销模式是怎样的

分销模式就是每一级分销商均可以往下再发展分销商。赚取两类佣金，也即店铺产品销售佣金与店铺推广佣金。
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、网络营销能使消费者拥有比传统营销更大的选择自由。消费者也可以根据自己的特点和需求在全球范围内不受地域、时间限制，快速寻找自己的产品，并能进行充分的比较，有利于节省消费者的交易时间与交易成本。此外，网络营销还可以帮助企业实现与消费者的一对一沟通，便于企业针对消费者的个别需要，提供一对一的个性化服务。

网络营销作为传统营销的延伸与发展，它既有与传统营销共性的一面，也有区别于传统营销的一面。搜到网认为随着互联网的飞速发展网络营销的其特点也表现得越来越突出。