如何解决代理模式详解的原理详解

 我特意将本系列改了下名字，原名是《设计模式学习之路》，原因是因为之前写过一篇《spring源码学习之路》，但是我感觉本次写二十三种设计模式，更多的还是分享给各位自己的理解，所以感觉学习之路有点不合适，另外，从本章开始，正式启用本人称呼，LZ。

               好了，废话至此，本章接着讨论第二种要介绍的设计模式，代理模式。

               LZ不希望写的东西与网络上的资料千篇一律，所以这一系列不会像很多典型文章一章，只是列出这个模式的定义以及一堆适用的情况，然后就是一堆这个模式的各个角色，对于这种罗列LZ并不反对，相比之下会比较清晰，但是如果脱离了实际，就会导致看的人特别是初学者觉得设计模式很陌生很遥远。

               LZ并不反对这种教学式的标准模式，但说实话，LZ本人看这种帖子从来都感觉收获不大，看一遍看一遍，到现在都没记住那些各个适用的情况与一堆乱七八糟的角色。

               所以LZ探讨代理模式，不会再按这个步骤进行，而是跟着自己的思维进行。

               首先代理模式，可以分为两种，一种是静态代理，一种是动态代理。

               两种代理从虚拟机加载类的角度来讲，本质上都是一样的，都是在原有类的行为基础上，加入一些多出的行为，甚至完全替换原有的行为。

               静态代理采用的方式就是我们手动的将这些行为换进去，然后让编译器帮我们编译，同时也就将字节码在原有类的基础上加入一些其他的东西或者替换原有的东西，产生一个新的与原有类接口相同却行为不同的类型。

               说归说，我们来真实的去试验一下，实验的话需要找一个示例，就拿我们的数据库连接来做例子吧。

               我们都知道，数据库连接是很珍贵的资源，频繁的开关数据库连接是非常浪费服务器的CPU资源以及内存的，所以我们一般都是使用数据库连接池来解决这一问题，即创造一堆等待被使用的连接，等到用的时候就从池里取一个，不用了再放回去，数据库连接在整个应用启动期间，几乎是不关闭的，除非是超过了最大闲置时间。

               但是在程序员编写程序的时候，会经常使用connection.close()这样的方法，去关闭数据库连接，而且这样做是对的，所以你并不能告诉程序员们说，你们使用连接都不要关了，去调用一个其他的类似归还给连接池的方法吧。这是不符合程序员的编程思维的，也很勉强，而且具有风险性，因为程序员会忘的。

               解决这一问题的办法就是使用代理模式，因为代理模式可以替代原有类的行为，所以我们要做的就是替换掉connection的close行为。

               下面是connection接口原有的样子，我去掉了很多方法，因为都类似，全贴上来占地方。

[java] view plain copy

1. import java.sql.SQLException;  
2. import java.sql.Statement;  
3. import java.sql.Wrapper;  
4.   
5. public interface Connection  extends Wrapper {  
6.       
7.     Statement createStatement() throws SQLException;  
8.       
9.     void close() throws SQLException;  
10.       
11. }  

              这里只贴了两个方法，但是我们代理的精髓只要两个方法就能掌握，下面使用静态代理，采用静态代理我们通常会使用组合的方式，为了保持对程序猿是透明的，我们实现Connection这个接口。

              如下所示。

[java] view plain copy

1. import java.sql.SQLException;  
2. import java.sql.Statement;  
3.   
4.   
5. public class ConnectionProxy implements Connection{  
6.       
7.     private Connection connection;  
8.       
9.     public ConnectionProxy(Connection connection) {  
10.         super();  
11.         this.connection = connection;  
12.     }  
13.   
14.     public Statement createStatement() throws SQLException{  
15.         return connection.createStatement();  
16.     }  
17.       
18.     public void close() throws SQLException{  
19.         System.out.println("不真正关闭连接，归还给连接池");  
20.     }  
21.   
22. }  

                我们在构造方法中让调用者强行传入一个原有的连接，接下来我们将我们不关心的方法，交给真正的Connection接口去处理，就像createStatement方法一样，而我们将真正关心的close方法用我们自己希望的方式去进行。

                此处为了更形象，LZ给出一个本人写的非常简单的连接池，意图在于表明实现的思路。下面我们来看一下连接池的变化，在里面注明了变化点。

[java] view plain copy

1. import java.sql.Connection;  
2. import java.sql.DriverManager;  
3. import java.sql.SQLException;  
4. import java.util.LinkedList;  
5.   
6. public class DataSource {  
7.       
8.     private static LinkedList<Connection> connectionList = new LinkedList<Connection>();  
9.       
10.     static{  
11.         try {  
12.             Class.forName("com.mysql.jdbc.Driver");  
13.         } catch (ClassNotFoundException e) {  
14.             e.printStackTrace();  
15.         }  
16.     }  
17.       
18.     private static Connection createNewConnection() throws SQLException{  
19.         return DriverManager.getConnection("url","username", "password");  
20.     }  
21.       
22.     private DataSource(){  
23.         if (connectionList == null || connectionList.size() == 0) {  
24.             for (int i = 0; i < 10; i++) {  
25.                 try {  
26.                     connectionList.add(createNewConnection());  
27.                 } catch (SQLException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.             }  
31.         }  
32.     }  
33.       
34.     public Connection getConnection() throws Exception{  
35.         if (connectionList.size() > 0) {  
36.             //return connectionList.remove();  这是原有的方式，直接返回连接，这样可能会被程序员把连接给关闭掉  
37.             //下面是使用代理的方式，程序员再调用close时，就会归还到连接池  
38.             return new ConnectionProxy(connectionList.remove());  
39.         }  
40.         return null;  
41.     }  
42.       
43.     public void recoveryConnection(Connection connection){  
44.         connectionList.add(connection);  
45.     }  
46.       
47.     public static DataSource getInstance(){  
48.         return DataSourceInstance.dataSource;  
49.     }  
50.       
51.     private static class DataSourceInstance{  
52.           
53.         private static DataSource dataSource = new DataSource();  
54.           
55.     }  
56.       
57. }  

                连接池我们把它做成单例，所以假设是上述连接池的话，我们代理中的close方法可以再具体化一点，就像下面这样，用归还给连接池的动作取代关闭连接的动作。

[java] view plain copy

1. public void close() throws SQLException{  
2.     DataSource.getInstance().recoveryConnection(connection);  
3. }  

                好了，这下我们的连接池返回的连接全是代理，就算程序员调用了close方法也只会归还给连接池了。

                我们使用代理模式解决了上述问题，从静态代理的使用上来看，我们一般是这么做的。

                1，代理类一般要持有一个被代理的对象的引用。

                2，对于我们不关心的方法，全部委托给被代理的对象处理。

                3，自己处理我们关心的方法。

                这种代理是死的，不会在运行时动态创建，因为我们相当于在编译期，也就是你按下CTRL+S的那一刻，就给被代理的对象生成了一个不可动态改变的代理类。

               静态代理对于这种，被代理的对象很固定，我们只需要去代理一个类或者若干固定的类，数量不是太多的时候，可以使用，而且其实效果比动态代理更好，因为动态代理就是在运行期间动态生成代理类，所以需要消耗的时间会更久一点。就像上述的情况，其实就比较适合使用静态代理。

               下面介绍下动态代理，动态代理是JDK自带的功能，它需要你去实现一个InvocationHandler接口，并且调用Proxy的静态方法去产生代理类。

               接下来我们依然使用上面的示例，但是这次该用动态代理处理，我们来试一下看如何做。

[java] view plain copy

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Method;  
3. import java.lang.reflect.Proxy;  
4. import java.sql.Connection;  
5.   
6.   
7. public class ConnectionProxy implements InvocationHandler{  
8.       
9.     private Connection connection;  
10.       
11.     public ConnectionProxy(Connection connection) {  
12.         super();  
13.         this.connection = connection;  
14.     }  
15.   
16.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
17.         //这里判断是Connection接口的close方法的话  
18.         if (Connection.class.isAssignableFrom(proxy.getClass()) && method.getName().equals("close")) {  
19.             //我们不执行真正的close方法  
20.             //method.invoke(connection, args);  
21.             //将连接归还连接池  
22.             DataSource.getInstance().recoveryConnection(connection);  
23.             return null;  
24.         }else {  
25.             return method.invoke(connection, args);  
26.         }  
27.     }  
28.       
29.     public Connection getConnectionProxy(){  
30.         return (Connection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Connection.class}, this);  
31.     }  
32.       
33. }  

               上面是我们针对connection写的动态代理，InvocationHandler接口只有一个invoke方法需要实现，这个方法是用来在生成的代理类用回调使用的，关于动态代理的原理一会做详细的分析，这里我们先只关注用法。很显然，动态代理是将每个方法的具体执行过程交给了我们在invoke方法里处理。而具体的使用方法，我们只需要创造一个ConnectionProxy的实例，并且将调用getConnectionProxy方法的返回结果作为数据库连接池返回的连接就可以了。

               上述便是我们针对connection做动态代理的方式，但是我们从中得不到任何好处，除了能少写点代码以外，因为这个动态代理还是只能代理Connection这一个接口，如果我们写出这种动态代理的方式的话，说明我们应该使用静态代理处理这个问题，因为它代表我们其实只希望代理一个类就好。从重构的角度来说，其实更简单点，那就是在你发现你使用静态代理的时候，需要写一大堆重复代码的时候，就请改用动态代理试试吧。

               通常情况下，动态代理的使用是为了解决这样一种问题，就是我们需要代理一系列类的某一些方法，最典型的应用就是我们前段时间讨论过的springAOP，我们需要创造出一批代理类，切入到一系列类当中的某一些方法中。下面给出一个经常使用的动态代理方式。

[java] view plain copy

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Method;  
3. import java.lang.reflect.Proxy;  
4.   
5.   
6. public class DynamicProxy implements InvocationHandler{  
7.       
8.     private Object source;  
9.       
10.     public DynamicProxy(Object source) {  
11.         super();  
12.         this.source = source;  
13.     }  
14.       
15.     public void before(){  
16.         System.out.println("在方法前做一些事，比如打开事务");  
17.     }  
18.       
19.     public void after(){  
20.         System.out.println("在方法返回前做一些事，比如提交事务");  
21.     }  
22.   
23.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
24.         //假设我们切入toString方法，其他其实也是类似的，一般我们这里大部分是针对特定的方法做事情的，通常不会对类的全部方法切入  
25.         //比如我们常用的事务管理器，我们通常配置的就是对save,update,delete等方法才打开事务  
26.         if (method.getName().equals("toString")) {  
27.             before();  
28.         }  
29.         Object result = method.invoke(source, args);  
30.         if (method.getName().equals("toString")) {  
31.             after();  
32.         }  
33.         return result;  
34.     }  
35.       
36.     public Object getProxy(){  
37.         return Proxy.newProxyInstance(getClass().getClassLoader(), source.getClass().getInterfaces(), this);  
38.     }  
39.       
40.       
41. }  

                上述我做了一些注释，其实已经说明一些问题，这个代理类的作用是可以代理任何类，因为它被传入的对象是Object，而不再是具体的类，比如刚才的Connection，这些产生的代理类在调用toString方法时会被插入before方法和after方法。

                动态代理有一个强制性要求，就是被代理的类必须实现了某一个接口，或者本身就是接口，就像我们的Connection。

                道理其实很简单，这是因为动态代理生成的代理类是继承Proxy类的，并且会实现被你传入newProxyInstance方法的所有接口，所以我们可以将生成的代理强转为任意一个代理的接口或者Proxy去使用，但是Proxy里面几乎全是静态方法，没有实例方法，所以转换成Proxy意义不大，几乎没什么用。假设我们的类没有实现任何接口，那么就意味着你只能将生成的代理类转换成Proxy，那么就算生成了，其实也没什么用，而且就算你传入了接口，可以强转，你也用不了这个没有实现你传入接口的这个类的方法。

               你可能会说，假设有个接口A，那我将接口A传给newProxyInstance方法，并代理一个没实现接口A的类B，但类B与接口A有一样的方法可以吗？

               答案是可以的，并且JDK的动态代理只认你传入的接口，只要你传入，你就可以强转成这个接口，这个一会解释，但是你无法在invoke方法里调用method.invoke方法，也就是说，你只能全部替换A接口的方法，而不能使用类B中原有与接口A方法描述相同的方法，这是因为invoke中传入的Method的class信息是接口A，而类B因为没实现接口A，所以无法执行传入的Method，会抛出非法参数异常。

               下面我贴出测试代码，各位可以自己试一下，具体为何会这样是在后面解释的，这里不再多做解释。

              先是一个普通接口。

[java] view plain copy

1. public interface TestInterface {  
2.   
3.     void method1();  
4.       
5.     void method2();  
6.       
7.     void method3();  
8. }  

            然后是一个类，和接口一模一样的方法，但是就是没实现这个接口。

[java] view plain copy

1. public class TestClass{  
2.   
3.     public void method1() {  
4.         System.out.println("TestClass.method1");  
5.     }  
6.   
7.     public void method2() {  
8.         System.out.println("TestClass.method2");  
9.     }  
10.   
11.     public void method3() {  
12.         System.out.println("TestClass.method3");  
13.     }  
14.   
15. }  

               下面是测试类。

[java] view plain copy

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Method;  
3. import java.lang.reflect.Proxy;  
4.   
5.   
6. public class DynamicProxy implements InvocationHandler{  
7.       
8.     private Object source;  
9.       
10.     public DynamicProxy(Object source) {  
11.         super();  
12.         this.source = source;  
13.     }  
14.   
15.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
16.         System.out.println("接口的方法全部变成这样了");  
17.         //这里source是TestClass，但是我们不能使用反射调用它的方法，像下面这样，放开这一行会抛异常  
18.         //return method.invoke(source, args);  
19.         return null;  
20.     }  
21.       
22.     public static void main(String[] args) {  
23.         //只要你传入就可以强转成功  
24.         TestInterface object =  (TestInterface) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{TestInterface.class}, new DynamicProxy(new TestClass()));  
25.         object.method1();  
26.         object.method2();  
27.         object.method3();  
28.     }  
29. }  

               上面我们运行就会发现接口的方法全部都只能输出一个很2的字符串了。如果是要继续使用TestClass的方法也不是不行，只要你确认你传入的类包括了所有你传入的接口的方法，只是没实现这些接口而已，那么你可以在invoke中这样使用。

[java] view plain copy

1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
2.         System.out.println("before");  
3.         Method sourceMethod = source.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());  
4.         sourceMethod.setAccessible(true);  
5.         Object result = sourceMethod.invoke(source, args);  
6.         System.out.println("after");  
7.         return result;  
8.     }  

                这就与你实现接口的表现行为一致了，但是我们本来就只需要一句method.invoke就可以了，就因为没实现接口就要多写两行，所以这种突破JDK动态代理必须实现接口的行为就有点画蛇添足了。因为你本来就实现了该接口的方法，只是差了那一句implements而已。

               上面写这个例子只是为了解释LZ当初的疑惑，因为LZ曾一度认为不实现接口就不能使用动态代理，现在想想那时候LZ有点2，呵呵。

               好了，从现在开始，我们开始详细讲解动态代理的原理，这算是进阶篇，如果是新手的话，可以跳过下面的内容，因为现在还没必要知道这些，而且弄不好会越看越蒙，不过仅仅是LZ个人建议，你要有耐心，完全可以继续看下去。

               接下来我们结合源码去看一下，代理类是如何产生的，首先当然就是要进入Proxy的newProxyInstance方法，这里是产生代理的入口，源码如下。

[java] view plain copy

1.    public static Object newProxyInstance(ClassLoader loader,  
2.                   Class<?>[] interfaces,  
3.                   InvocationHandler h)  
4. throws IllegalArgumentException  
5.    {  
6. if (h == null) {  
7.     throw new NullPointerException();  
8. }  
9.   
10. /* 
11.  * Look up or generate the designated proxy class. 
12.  */  
13. Class cl = getProxyClass(loader, interfaces);  
14.   
15. /* 
16.  * Invoke its constructor with the designated invocation handler. 
17.  */  
18. try {  
19.     Constructor cons = cl.getConstructor(constructorParams);  
20.     return (Object) cons.newInstance(new Object[] { h });  
21. } catch (NoSuchMethodException e) {  
22.     throw new InternalError(e.toString());  
23. } catch (IllegalAccessException e) {  
24.     throw new InternalError(e.toString());  
25. } catch (InstantiationException e) {  
26.     throw new InternalError(e.toString());  
27. } catch (InvocationTargetException e) {  
28.     throw new InternalError(e.toString());  
29. }  
30.    }  

               这个方法其实很简单，首先获取了代理类的运行时Class引用，然后调用了这个Class中的构造方法，这个构造方法只有一个参数，正是InvocationHandler接口，由此产生了一个代理类的实例。那么关键的地方就在于如何获取的代理类运行时的class信息的呢？我们进入getProxyClass方法看一下。为了方便起见，我直接加注释，这个方法需要解释的地方比较多。
（完）
http://ji63658820.blog.sohu.com/
http://zhizhi01417.blog.sohu.com/
http://baquanzhaojiure.blog.sohu.com/
http://kenchi0072.blog.sohu.com/
http://zifang439602.blog.sohu.com/
http://gongpuzhishuozh.blog.sohu.com/
http://qiaoxun78874.blog.sohu.com/
http://juyukehuazai.blog.sohu.com/
http://naoqun271707.blog.sohu.com/
http://ranghui584859.blog.sohu.com/
http://kan85274856.blog.sohu.com/
http://jidou50557525.blog.sohu.com/
http://yunqun25200989.blog.sohu.com/
http://pangcao9153130.blog.sohu.com/
http://koufuyi599899.blog.sohu.com/
http://sifan76579.blog.sohu.com/
http://xian40097124.blog.sohu.com/
http://zhengdi824808.blog.sohu.com/
http://huiyuan30898.blog.sohu.com/
http://tuzhi052086.blog.sohu.com/
http://zigan813704.blog.sohu.com/
http://aopu127791.blog.sohu.com/
http://zhixun2111431.blog.sohu.com/
http://yonglu5882289.blog.sohu.com/
http://blog.sohu.com/home/news/index.htm
http://shi05778335.blog.sohu.com/
http://duntao5889640.blog.sohu.com/
http://ying56663881.blog.sohu.com/
http://miyou1chao.blog.sohu.com/
http://quebeng9112.blog.sohu.com/
http://langpai3822036.blog.sohu.com/
http://shangguai483499.blog.sohu.com/
http://jiaoyi97308.blog.sohu.com/
http://shazhun795212.blog.sohu.com/
http://fufang6180765.blog.sohu.com/
http://xianlekangkao.blog.sohu.com/
http://duxing0651.blog.sohu.com/
http://tuohaoba022375.blog.sohu.com/
http://yuji3gui153382.blog.sohu.com/
http://zemu1426600.blog.sohu.com/
http://yacang160402.blog.sohu.com/
http://gua20742393.blog.sohu.com/
http://jisuweichun.blog.sohu.com/
http://pudu6738715.blog.sohu.com/
http://leitou52561606.blog.sohu.com/
http://dicisixian.blog.sohu.com/
http://dituo654174.blog.sohu.com/
http://tutuo81160508.blog.sohu.com/
http://guaqiaotushuqin.blog.sohu.com/
http://tanjiaju772135.blog.sohu.com/
http://xia22401507.blog.sohu.com/
http://pojiao2520371.blog.sohu.com/
http://chicurangou.blog.sohu.com/
http://luzaweituan.blog.sohu.com/
http://chengfen860412.blog.sohu.com/
http://poba73704219.blog.sohu.com/
http://mei89825164.blog.sohu.com/
http://duang32836452.blog.sohu.com/
http://jiubei390139.blog.sohu.com/
http://xieraoqiefankao.blog.sohu.com/
http://yilang47832.blog.sohu.com/
http://sijiao2818166.blog.sohu.com/
http://lutong084166.blog.sohu.com/
http://yunbai038826.blog.sohu.com/
http://chuishao96160.blog.sohu.com/
http://duanao45202.blog.sohu.com/
http://zena58309333.blog.sohu.com/
http://zhaopouga.blog.sohu.com/
http://jijiziluzi.blog.sohu.com/
http://youmu86072747.blog.sohu.com/
http://yiqiao0799346.blog.sohu.com/
http://fangqiang2gong.blog.sohu.com/
http://luxuan5003.blog.sohu.com/
http://lanlue1673873.blog.sohu.com/
http://wopiao8981.blog.sohu.com/
http://yiliezhiyun.blog.sohu.com/
http://zenxunaozhundi.blog.sohu.com/
http://xionggong001752.blog.sohu.com/
http://zhichenlintugui.blog.sohu.com/
http://queyi41528049.blog.sohu.com/
http://jiejia423144.blog.sohu.com/
http://shaogangliaoqin.blog.sohu.com/
http://jiuchun3411223.blog.sohu.com/
http://jiaoba81253.blog.sohu.com/
http://fangjiao495408.blog.sohu.com/
http://fuqiang376.blog.sohu.com/
http://zouhuiyongtanch.blog.sohu.com/
http://xiqiao92002.blog.sohu.com/
http://shu82355473.blog.sohu.com/
http://ziyuan254736.blog.sohu.com/
http://sitan4pi158934.blog.sohu.com/
http://jueyan6xia.blog.sohu.com/
http://dongliang43145.blog.sohu.com/
http://yiwei71321060.blog.sohu.com/
http://cizhuang49210.blog.sohu.com/
http://fenpan87260.blog.sohu.com/
http://xiyo0267815.blog.sohu.com/
http://yingrong5mei.blog.sohu.com/
http://jingtong2234.blog.sohu.com/
http://tuikang744040.blog.sohu.com/
http://depaisiyi.blog.sohu.com/
http://olu5514216.blog.sohu.com/
http://gou86478183.blog.sohu.com/
http://weiyuan1song.blog.sohu.com/
http://jiaoxia718784.blog.sohu.com/
http://taoji03753000.blog.sohu.com/
http://zhunpanxianyunf.blog.sohu.com/
http://linyediweijiang.blog.sohu.com/
http://lanyi47493068.blog.sohu.com/
http://bidui003324.blog.sohu.com/
http://xunqie35956392.blog.sohu.com/
http://puyi22288.blog.sohu.com/
http://jiazhe3155.blog.sohu.com/
http://gan82261201.blog.sohu.com/
http://jiazhe3155.blog.sohu.com/
http://yong06919851.blog.sohu.com/
http://qinlin934705.blog.sohu.com/
http://zhangji762369.blog.sohu.com/
http://xinhan954.blog.sohu.com/
http://ozhishangba.blog.sohu.com/
http://shaxin5933667.blog.sohu.com/
http://jiuyazhijidi.blog.sohu.com/
http://ji00478205.blog.sohu.com/
http://daoxian5666001.blog.sohu.com/
http://duxuan1146.blog.sohu.com/
http://xiegui137392.blog.sohu.com/
http://jiuao92856238.blog.sohu.com/
http://pusong8394.blog.sohu.com/
http://jidao8227035.blog.sohu.com/
http://shiqi625077.blog.sohu.com/
http://chijia501914.blog.sohu.com/
http://zhongshi537706.blog.sohu.com/
http://zhanglu4738465.blog.sohu.com/
http://shuojia670.blog.sohu.com/
http://ke63240682.blog.sohu.com/
http://rangyongziliang.blog.sohu.com/
http://xunshan7916.blog.sohu.com/
http://nacong632878.blog.sohu.com/
http://dumeihailazhuan.blog.sohu.com/
http://langao48260378.blog.sohu.com/
http://tulan64540.blog.sohu.com/
http://qinqiang5si.blog.sohu.com/
http://langren750634.blog.sohu.com/
http://tuoshou730823.blog.sohu.com/
http://beixian305396.blog.sohu.com/
http://koutuomeijingtu.blog.sohu.com/
http://kehui0240677.blog.sohu.com/
http://han36991002.blog.sohu.com/
http://huituo863.blog.sohu.com/
http://youqun0rang.blog.sohu.com/
http://pujiu3104779.blog.sohu.com/
http://jiuba0958174.blog.sohu.com/
http://fugu1860309345.blog.sohu.com/
http://bazhi047569.blog.sohu.com/
http://wogan4515.blog.sohu.com/
http://chuncheng1chao.blog.sohu.com/
http://qingcheng367532.blog.sohu.com/
http://linshanyeanhan.blog.sohu.com/
http://jushi7pa051073.blog.sohu.com/
http://za67896020.blog.sohu.com/
http://jiehui5chi.blog.sohu.com/
http://yongtuo61728.blog.sohu.com/
http://daofu64180926.blog.sohu.com/
http://jizhuo0huan.blog.sohu.com/
http://ziren3128194.blog.sohu.com/
http://fuqiangrangxia.blog.sohu.com/
http://yunbu5jue.blog.sohu.com/
http://hejiao9593454.blog.sohu.com/
http://poyeduhai.blog.sohu.com/
http://zhan37581019.blog.sohu.com/
http://laotan164675.blog.sohu.com/
http://xieqinkaoche.blog.sohu.com/
http://liaorao0254.blog.sohu.com/
http://koucong9mei.blog.sohu.com/
http://pamu6355864.blog.sohu.com/
http://jiaotuo350363.blog.sohu.com/
http://bachun6523.blog.sohu.com/
http://sike461935.blog.sohu.com/
http://latuan317871.blog.sohu.com/

http://konglan6560643.blog.sohu.com/

[ja