Kotlin实现代理模式

说白了，代理模式就是给一个类提供代理类，让外部可以调用代理类而不需要调用类的本身。
这样做的好处，当需求产生差异时，我们只需要修改代理类中的方法，而不需要改变类本身，极大简化了本身类的逻辑。

好了，语言是苍白的，代码才是明明白白的。

上重点。

静态代理

静态代理需要一个接口

interface IUserInfo {
    fun getUserInfo(str:String):String
}

需要代理的类

class MainUserInfo:IUserInfo {
    override fun getUserInfo(str: String): String {
        return mainMethod()+str
    }


    private fun mainMethod(): String {
        return "I'm mainMethod"
    }
}

代理类

//class StaticProxyUserInfo constructor(iUserInfo:IUserInfo):IUserInfo {
//    private val iUserInfo:IUserInfo = iUserInfo
//    
//    override fun getUserInfo(str: String): String {
//        return iUserInfo.getUserInfo(str)
//    }
//}
//在kotlin有更加酷的写法，一行搞定
class StaticProxyUserInfo constructor(iUserInfo:IUserInfo):IUserInfo by iUserInfo

调用

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val mainInfo = MainUserInfo()
        val proxyUserInfo = StaticProxyUserInfo(mainInfo)
        tv.setOnClickListener {
            tv.text = proxyUserInfo.getUserInfo("代理")
        }
    }
}

效果

动态代理

动态代理和静态代理的区别在于

• 不需要实现接口
• 不需要代理类（由虚拟机来实现）
  优点：我们都知道传统的java实现静态代理时，需要为每一个需要代理的类写一个代理类，如果需要100个代理类基本就要累死了。动态代理就是为了让代码简化，从而优雅的实现代理。
  从反向来说呢，如果代理之前并不确定需要代理的类，也只能使用动态代理。

public static void main(String[] args) {
    Shopping women = new ShoppingImpl();
    // 正常购物
    System.out.println(Arrays.toString(women.doShopping(100)));
    // 招代理
    women = (Shopping) Proxy.newProxyInstance(Shopping.class.getClassLoader(),
            women.getClass().getInterfaces(), new ShoppingHandler(women));

    System.out.println(Arrays.toString(women.doShopping(100)));
}

kotlin是没有动态代理的Api，直接使用java代码转换会报错。本身by的方式已经对代理做了极大简化，所以才没有特意去做动态代理的API。