民以食为天告诉我们，食品与我们的生活息息相关，不可或缺。而在当前的快消品市场中，食品也是很多人争相做的一个品类，因为不管时代怎样变迁，社会怎样进步，食品行业的发展都会永不停歇。那么，想要做区域食品总代理商，应该怎么做呢？连凯汇商食品饮料招商网小编为大家提供以下建议。
 
做地区总代理商是否具备以下条件


首先，作为厂家的代理商，你必须要来全面的了解企业，如企业精神、核心、政策等等，并且要做好与企业相配合的市场操作思路、品牌推广等；
其次，你要在该区域的强大配送能力，有自己强大且稳固的渠道客情等等；
最后，一定要看你是否具备一定的资金能力，因为作为一名地区代理商要考虑的还有压货、促销、客情维护等，都需要一定的资金积压。
 
如何才能成为地区总代理商
 
要想做地区品牌代理商，需要向自己所代理的品牌申请，得到其实力认定资格之后，需要和所代理的厂家签订合同，得到其代理授权书，之后你就会成为该品牌这一区域的代理商，负责这一地区的市场开拓和维护。
 
成为地区总代理商后需要做什么
 
要知道，作为该都去的代理商之后，凡是在该区域所属范围内的该品牌代理，他们的消费、销售都能为你代理受益，相比小代理，利润空间更大。同时，作为地区代理商的你，也要为你所负责的区域代理做好服务工作，达到互利互惠的共赢局面。更多请访问食品招商资讯网：
http://www.lkhs.cn/xw/！

代理模式

     日常生活中代理司空见惯的，比如某地区总代理，直白点就是中间商。在代码的世界里也有这种“中间商”，不过这个“中间商”不收差价，有时候甚至给你点额外的“小惊喜”。

    代理模式有3个要素：接口、目标类(委托人)、代理类(中间商)。目标类、代理类都实现同一个接口，代理类有一个目标类的属性。客户所有的请求都是到代理类对象，代理对象转发到目标对象。



  



那么前面说的“小惊喜”是什么呢？ 代理对象在找目标对象之前，可以自己做一些扩展。

代理商可以提前备一些货，直接给到你，无需找厂家 ---- 缓存
	
如果某个品牌货厂家不生产了，可直接告诉你，无需你去厂家确认 ---- 扩展限制条件
所以代理模式有以下好处：

屏蔽底层的实现；
	
遵守设计模式的开闭原则，欢迎扩展、拒绝修改。
动态代理

    一般情况要实现代理模式，开发者需要显示创建代理类，然后编译打包运行，我们称为静态代理。不过，由于jvm类加载的机制，允许开发者主动加载某个类，开发者可以在程序运行时动态创建代理类，然后通过类加载器加载到jvm，实例化代理对象，这就是动态代理。动态代理的核心是如何生成代理类。目前，有两种方式生成动态代理：JDK动态代理、CGLIB动态代理。

JDK动态代理

    jdk动态代理是jdk自带的动态代理方式，核心组件有java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler(接口)。jdk动态代理稍微修改了代理模式模型-引入了InvocationHandler。jdk动态代理生成代理类之后的类图模型如下：



    jdk生成的代理类ProxyClass继承java.lang.reflect.Proxy，后者有个成员变量h(java.lang.reflect.InvocationHandler)，开发者可以在InvocationHandler实现类中关联目标对象(TargetClass)。创建代理对象的实现需要传入InvocationHandler的实现类。引入InvocationHandler有两点作用：

创建代理类更简单，直接把所有的请求转发到InvocationHandler#invoke即可，由InvocationHandler#invoke完成分发调用目标对象的方法；
	
让开发者可以非常方便实现扩展功能，InvocationHandler#invoke在分发请求之前、之后、异常等位置扩展功能。
    jdk动态代理使用起来很简单，直接拿例子说吧。如下图，假设有LocalWriterPrinter实现3个接口Priter、Writer、WriterPrinter，我们对目标对象(LocalWriterPrinter)做动态代理，在方法前后加上额外的信息。



目标类LocalWriterPrinter实现3个接口： 

public class LocalWriterPrinter implements Writer, Printer, WriterPrinter {
    public String print(String text) {
         System.out.println(this.getClass().getSimpleName() + " print:" + text);
         return text;
    }

    public String write(String text) {
        System.out.println(this.getClass().getSimpleName() + " write:" + text);
        return text;
    }
}

Jdk动态代理是通过InvocationHandler#invoke分发代理请求，所以需要一个InvocationHandler实现类WriterPrinterInvocationHandler，目标类对象printer是其成员变量。我们在调用目标类对象之前、之后还有finlly都做一个额外的事情(例子只打个日志)

public class WriterPrinterInvocationHandler implements InvocationHandler {

    private Object printer;

    public WriterPrinterInvocationHandler(Object writerPrinter) {
        this.printer = writerPrinter;
    };

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            System.out.println("before advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
            Object ret = method.invoke(printer, args);
            System.out.println("after advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
            return ret;
        } finally {
            System.out.println("finally advice:" + method.getDeclaringClass().getSimpleName() + "." +  method.getName());
        }
    }
}

public class JdkDynamicDemo {

    public static void main(String... args) {
        //创建目标类对象
        LocalWriterPrinter target= new LocalWriterPrinter();
        //创建InvocationHander，并将目标类对象作为属性
        WriterPrinterInvocationHandler handler = new WriterPrinterInvocationHandler(target);
  
        Class<?>[] infs = {Printer.class, WriterPrinter.class, Writer.class};
        //调用Proxy.newProxyInstance创建代理类对象
        Object writerPrinter = Proxy.newProxyInstance(JdkDynamicDemo.class.getClassLoader(), infs, handler);
        //执行代理类对象的print方法
        Printer printer = (Printer)writerPrinter;
        printer.print("jdk dynamic");
        //执行代理类对象的write方法
        Writer writer = (Writer) writerPrinter;
        writer.write("jdk dynamic");
    }
}

运行结果如下：



我们看以下生成的代理类是什么样的（用jdk的HSDB工具导出代理类）

package com.sun.proxy;

import com.focuse.dynamicdemo.jdkproxy.Printer;
import com.focuse.dynamicdemo.jdkproxy.Writer;
import com.focuse.dynamicdemo.jdkproxy.WriterPrinter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Printer, WriterPrinter, Writer {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;
    private static Method m4;

    public $Proxy0(InvocationHandler var1) {
        super(var1);
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.focuse.dynamicdemo.jdkproxy.Printer").getMethod("print", Class.forName("java.lang.String"));
            //笔者注：write方法来源于WritePrinter，因为传入的接口数组中WritePrinter接口在前,Writer接口在后
            m4 = Class.forName("com.focuse.dynamicdemo.jdkproxy.WriterPrinter").getMethod("write", Class.forName("java.lang.String"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    public final boolean equals(Object var1) {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String write(String var1) {
        try {
            return (String)super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String print(String var1) {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
}

h就是创建代理对象时传入的InvocationHandler实例，看到代理类的代码一切都清晰了，所的请求的都转到InvocationHandler实例h处理。InvocationHandler#invoke第一个参数是代理对象，第二个参数是被代理接口的method，第三个参数请求的实际参数。显而易见，jdk动态代理有以下特点：

JDK动态代理支持对Interface生成代理类，不支持对Class生成代理类；
	
所有的代理请求都是通过InvocationHandler#invoke转发，开发者可以在这里干任何想干的事情；
	
如果多个接口类中有相同签名的方法(名称、参数个数、参数类型)，代理类传给InvocationHandler#invoke的method参数来源于第一个接口类，例如本例中write方法就是来源于WritePrinter接口。
CGLIB动态代理

    不同于JDK动态代理，CGLIB是通过生成目标类的子类实现的。核心组件是net.sf.cglib.proxy.Enhancer和net.sf.cglib.proxy.Callback。Callback相当于JDK动态代理中的InvocationHandler。其实，CGLIB的功能只是增强父类的逻辑，要用它实现代理模式，需要在Callback里关联目标对象。子类的逻辑是如果Callback不为空执行Callback，否则执行父类方法。

    CGLIB提供四种Callback子类型，一般做动态代理的是net.sf.cglib.proxy.MethodInterceptor：



咋一看这个类图看不出是代理模式，我们转换一下画一个对象图就看得明白了。我们用黑心圆点表示实例关系，如下图，代理对象和目标对象都是目标类的实例，代理对象实际是目标类子类(代理类)的实例。



同样，我们举个小栗子，对Printer类做动态代理，并在print方法之前、之后、finally位置做一些扩展(本例仅仅打个日志)。首先看一下原来的Printer类

public class Printer {

    public String print(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }

    protected String print22(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }

    private String print33(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }
}

其次，实现一个MethodInterceptor，目标对象作为其成员变量，并在调用目标对象方法之前、之后、finally位置加上相应日志。

public class LocalPrinterCallback implements MethodInterceptor {

    Object target;

    public LocalPrinterCallback(Object target) {
        this.target = target;
    }
    //代理
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                            MethodProxy proxy) throws Throwable{
        try {
            System.out.println("before advice");
            //请求目标对象方法
            Object ret = method.invoke(target, args);
            System.out.println("after advice");
            return ret;
        }finally {
            System.out.println("finally advice");
        }
    }

}

接下来就是开始用CGLIB进行动态代理 

public class CglibDynamicDemo {

    public static void main(String... args) {
        //目标对象
        Printer target = new Printer();
        //callback  目标对象作为其成员变量
        LocalPrinterCallback localCallback = new LocalPrinterCallback(target);
        //创建enhancer类
        Enhancer enhancer = new Enhancer();
        //设置需要增强的类Printer
        enhancer.setSuperclass(Printer.class);
        //设置callback 相当于jdk动态代理的InvocationHandler
        enhancer.setCallback(localCallback);
        //创建代理类并返回代理对象
        Object object = enhancer.create();
        Printer proxy = (Printer)object; 
        //执行print方法
        proxy.print("cglib demo");
    }
}

运行结果如下，期望在增强的位置打出相应的信息：



我们看一下CGLIB生成的代理类是什么样的(也是用jdk的HSDB工具导出代理类) 。cglib生成的代理类比jdk动态代理生成的代理类相对复杂一些。不过，我们主要看一下print方法的实现，不难看出，print方法的逻辑是当callback不为空null时就去调用callback的net.sf.cglib.proxy.MethodInterceptor#intercept方法(本例中callback是MethodInterceptor类型)。同时，我们也看到cglib只对public和protected修饰的方法做代理，private方法则不做。

package com.focuse.dynamicdemo.cglibproxy;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class Printer$$EnhancerByCGLIB$$9402db17 extends Printer implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$print$0$Method;
    private static final MethodProxy CGLIB$print$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$print22$1$Method;
    private static final MethodProxy CGLIB$print22$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;

    public Printer$$EnhancerByCGLIB$$9402db17() {
        CGLIB$BIND_CALLBACKS(this);
    }

    static {
        CGLIB$STATICHOOK1();
    }

    ......(略)

    public final String print(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$print$0$Method, new Object[]{var1}, CGLIB$print$0$Proxy) : super.print(var1);
    }

   

    protected final String print22(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$print22$1$Method, new Object[]{var1}, CGLIB$print22$1$Proxy) : super.print22(var1);
    }

    

    ......（略）


    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer$$EnhancerByCGLIB$$9402db17");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"print", "(Ljava/lang/String;)Ljava/lang/String;", "print22", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer")).getDeclaredMethods());
        CGLIB$print$0$Method = var10000[0];
        CGLIB$print$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print", "CGLIB$print$0");
        CGLIB$print22$1$Method = var10000[1];
        CGLIB$print22$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print22", "CGLIB$print22$1");
        var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$2$Method = var10000[0];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[1];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[2];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[3];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    }

    final String CGLIB$print$0(String var1) {
        return super.print(var1);
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Printer$$EnhancerByCGLIB$$9402db17 var1 = (Printer$$EnhancerByCGLIB$$9402db17)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    final String CGLIB$print22$1(String var1) {
        return super.print22(var1);
    }

}

总结

这里介绍代理模式、动态代理以及动态代理的两种方式：JDK自带方式动态代理、CGLIB创建动态代理，总结一下

代理模式三要素：代理类(代理对象)、目标类(目标对象)、二者共同的接口
	
JDK动态代理引入了InvocationHandler接管并分发所有的请求
	
JDK动态代理只能对Interface做动态代理，不能对Class做代理
	
CGLIB对Class做代理，其实现方式是生成目标类的子类
	
CGLIB实现请求转发到目标对象是通过Callback接口，CGLIB提供了6中Callback子类型，常用做动态代理的是net.sf.cglib.proxy.MethodInterceptor
 

 

3月16日消息，2012年苹果游戏期待大作，国内首款用虚幻3引擎打造的移动平台大型3D动作游戏《战神之怒》中国区总代理正式确定。微云宣布，已与该游戏开发公司–卡尔维达成深度战略合作，并获得《战神之怒》在中国地区的独家运营权，并与该游戏海外区发行商Chillingo联手，势必将《战神之怒》打造为全球流行的移动游戏。

 

《战神之怒》作为用虚幻3引擎打造的移动端大型3D动作游戏，是微云和卡尔维展开深度战略合作的首款游戏。也是《战神之怒》将海外发行权代理签约chillingo后，为了能更好的在中国区本土化运营，服务好国内玩家，是选择与国内知名手机游戏发行商–微云合作的主要原因。



与此同时，微云一直致力于打造全球化的移动游戏运营平台，坚持多渠道的精品发展策略，为玩家提供优质的产品和服务。本次深度战略合作，也是微云推进游戏精品化战略的重要举措。与之前发行的《最后的防线》、《巅峰狂飙》、《枪火战线》等游戏一起，《战神之怒》的引进将不断的扩大微云游戏平台的优秀内容和产品线，更好的服务于国内玩家。



微云COO刘琦表示：“我们非常高兴能和这样优秀的团队及游戏合作，并坚信双方联合运营协作共赢。《战神之怒》作为用虚幻3引擎开发的国内首款移动端3D动作游戏，其高端的游戏品质一直得到大家的认可。微云将充分利用的全方位的渠道和强有力的平台，在本土化的过程中为玩家提供高品质的服务，让大家充分体验《战神之怒》游戏的魅力。”

双方表示，《战神之怒》的具体发布时间近期将会正式公布，但相信一定会给玩家们带来惊喜，和不同寻常的移动游戏体验。






Via  雷锋网

    

                    

                    

                    
                    
                    
10月9日消息，英雄互娱日前对外发布声明称，即日起，中止公司代理的移动游戏《NBA LIVE》（美职篮在线）在中国大陆地区所有推广活动。
声明内容显示，针对休斯顿火箭队总经理莫雷近日发表的有关中国香港的错误言论，以及NBA在此事上所表现出的纵容态度，英雄互娱表示强烈不满和谴责。
英雄互娱称，始终坚守国家利益高于一切的原则，坚决反对任何挑战国家主权及领土完整的言论和行为。即日起，中止公司代理的移动游戏《NBA LIVE》（美职篮在线）在中国大陆地区所有推广活动。
— 【 THE END 】—
往期精彩文章回顾：
| 点评锤子新机外观被前下属骂“厚颜无耻” 罗永浩道歉：希望还来得及补偿
| “滚！”央视、腾讯暂停NBA季前赛转播，NBA被中国市场“下架”！
| 十一假期国人消费力爆棚，国内旅游收入超6497亿，你花了多少？