java代理模式

代理模式

为什么要学习代理模式？因为这是SpringAOP的底层！ 【SpringAOP和SpingMVC}】

代理模式的分类：

• 静态代理

• 动态代理

代理就像这里的中介，帮助你去做向房东租房，你不能直接解出房东，而房东和中介是因为租房而联系在一起，所以租房是接口

静态代理

角色分析：

• 抽象角色(租房)：一般使用接口和抽象类来解决
• 真实角色(房东)：被代理的角色
• 代理角色(中介)：代理真实角色，被代理真实角色后，我们一般会做一些附属工作
• 客户：访问代理对象的人

代码步骤：

1. 接口

   package com.hong;
   
   //租房
   public interface Rent {
       public void rent();
   }
   
   

2. 真实角色

   package com.hong;
   
   public class Client {
       public static void main(String[] args) {
           //房东要租房子
           Host host = new Host();
           //代理，中介帮房东租房子，但是呢房东会加一些附属操作!
   //        host.rent();
           Proxy proxy = new Proxy(host);
           //你不用面对房东，直接找中介即可
           proxy.rent();
       }
   }
   
   

3. 代理角色

   package com.hong;
   
   public class Proxy implements Rent{
   
       private Host host;
   
       public Proxy(Host host) {
           this.host = host;
       }
   
       public Proxy() {
       }
   
       @Override
       public void rent() {
           host.rent();
           seeHost();
           fare();
           hetong();
   
       }
       //看房
       public void seeHost(){
           System.out.println("中介带你看房");
       }
       public void hetong(){
           System.out.println("签合同");
       }
       //收中介费
       public void fare(){
           System.out.println("收中介费");
       }
   }
   
   

4. 客户端访问代理角色

   package com.hong;
   
   //房东
   public class Host implements Rent{
       @Override
       public void rent() {
           System.out.println("房东要出租房子");
   
       }
   }
   
   

代理模式的好处：

• 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
• 公共也就就交给代理角色!实现了业务的分工!
• 公共业务发生扩展的时候，方便集中管理!

缺点：

• 一个真实角色就会产生一个代理角色;代码量会翻倍，开发效率会变低

AOP

用代理增加功能，不改动原有的代码，只改动代理类

package com.hong;

//真实对象
public class UserServiceImpl implements UserService {


    @Override
    public void add() {
        System.out.println("增加一个用户");

    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");

    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");

    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");

    }
}

package com.hong;

public class UserServiceProxy implements UserService{
    private UserServiceImpl userservice;

    public void setUserservice(UserServiceImpl userservice) {
        this.userservice = userservice;
    }

    @Override
    public void add() {
        log("add");
        userservice.add();
    }

    @Override
    public void delete() {
        log("delete");
        userservice.delete();

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }
    public void log(String msg){
        System.out.println("调用"+msg+"方法");
    }
}

package com.hong;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

package com.hong;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();


        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserservice(userService);
        proxy.add();
    }
}

动态代理

• 动态代理和静态代理角色一样
• 动态代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口—JDK动态代理
  • 基于类：cglib
  • java字节码实现：javasist

需要了解两个类：proxy：代理，lnvocationHandler：调用处理程序

静态代理的好处：

• 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
• 公共也就就交给代理角色!实现了业务的分工!
• 公共业务发生扩展的时候，方便集中管理!
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理，修改的成本极低

实现代码

动态代理

package com.hong.demo02;

import com.hong.xxh.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//自动生成代理
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object taget;

    public void setTaget(Object taget) {
        this.taget = taget;
    }

    //生成得到代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),taget.getClass().getInterfaces(),this);
    }


    //处理代理实例并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(taget, args);
        return result;
    }
}

接口

package com.hong.demo02;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

真实对象

package com.hong.demo02;

//真实对象
public class UserServiceImpl implements UserService {


    @Override
    public void add() {
        System.out.println("增加一个用户");

    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");

    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");

    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");

    }
}

客户端访问

package com.hong.demo02;

import com.hong.Proxy;
import com.hong.UserServiceImpl;

public class ClenClient {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTaget(userService);  //设置要代理的对象
        //动态生成代理
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

反序列化中动态代理的利用

我们将入口类定义为A，我们最理想的情况是 A[O] -> O.f，那么我们将传进去的参数O替换为B即可。但是在实战的情况下这种情况是极少的。

回到实战情况，比如我们的入口类A存在O.abc这个方法，也就是 A[O] -> O.abc；而 O 呢，如果是一个动态代理类，O的invoke方法里存在.f的方法，便可以漏洞利用了，我们还是展示一下。

A[O] -> O.abc O[O2] invoke -> O2.f // 此时将 B 去替换

O2 最后 ----> O[B] invoke -> B.f // 达到漏洞利用效果

就像readObject在反序列化中自动调用，invoke在动态代理的时候也自动调用，如果我们在invoke插入恶意代码，就可进行攻击例如

结果