【设计模式学习-07-代理模式】

【设计模式学习-07-代理模式】

1.代理模式

是SpringAOP的底层 [SpringAOP和SpringMVC]
代理模式的分类
静态代理
动态代理

2.静态代理

角色分析:
抽象角色: 一般会使用接口或抽象类来解决
真实角色: 被代理的角色
代理角色: 代理真实角色,代理真实角色后,我们一般会做一些附属操作
客户: 访问代理对象的人

2.1Rent

package proxy.proxystatic;
//租房
public interface Rent {
    public void rent();
}

2.2Host

package proxy.proxystatic;

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

2.3Proxy

package proxy.proxystatic;

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
        heTong();
        fare();
    }

    @Override
    public void rent() {
        host.rent();
    }
    public void see(){
        System.out.println("中介带你看房");
    }
    public void heTong(){
        System.out.println("中介带你看合同");
    }



    public void fare(){
        System.out.println("收中介费");
    }
}

2.4Client

package proxy.proxystatic;

public class Client {
    public static void main(String[] args) {
        //房东租房子
        Host host = new Host();
        host.rent();
        //代理，附属操作
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

2.5静态代理模式的好处:

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

2.6静态代理模式缺点:

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

3.增加功能采用代理模式

3.1UserService

package proxy.Proxy1;

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

3.2UserServiceImpl

package proxy.Proxy1;
//真实对象
public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("增加用户");

    }

    @Override
    public void update() {
        System.out.println("更新用户");

    }

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

    }

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

    }
}

3.3UserServiceProxy

package proxy.Proxy1;

public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

    public UserServiceImpl getUserService() {
        return userService;
    }

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public UserServiceProxy() {
    }

    public UserServiceProxy(UserServiceImpl userService) {
        this.userService = userService;
    }

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

    }

    @Override
    public void update() {
        log("update");
        userService.update();

    }

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

    }

    @Override
    public void query() {
        log("query");
        userService.query();

    }
    //增加日志功能
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

3.4Client

package proxy.Proxy1;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.add();
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
//        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
        userServiceProxy.delete();
        userServiceProxy.update();
    }
}

4.动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的,不是我们直接写好的
动态代理分为两大类 : 基于接口的动态代理,基于类的动态代理
基于接口-JDK动态代理
基于类: cglib
java字节码实现 : javassist
需要了解的两个类: Proxy: 代理, InvocationHandler: 调用处理程序

4.1InvocationHandler(调用处理程序)

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                               rent.getClass().getInterfaces(),this);
}

4.2Host

package proxy.proxydynamic;

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

4.3Rent

package proxy.proxydynamic;
//租房
public interface Rent {
    public void rent();
}

4.4ProxyInvocationHandler

package proxy.proxydynamic;

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

//用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public Rent getRent() {
        return rent;
    }

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质是使用反射实现
        Object result = method.invoke(rent, args);
        return result;
    }
}

4.5Client

package proxy.proxydynamic;

import proxy.proxystatic.Proxy;

public class Client {
    public static void main(String[] args) {
        //真是角色
        Host host = new Host();

        //代理角色
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理要调用的接口
        proxyInvocationHandler.setRent(host);
        Rent proxy = (Rent) proxyInvocationHandler.getProxy();
        proxy.rent();
    }
}

4.6总结

静态代理有的它都有，静态代理没有的，它也有！
可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

4.7动态代理工具类

通过放射获取当前方法的名字

public class ProxyInvocationHandler implements InvocationHandler {
   //被代理的接口
   private Object target;

   public void setTarget(Object target) {
       this.target = target;
  }

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

   // proxy : 代理类
   // method : 代理类的调用处理程序的方法对象.
   public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
       log(method.getName());
       //动态代理的本质,就是使用反射机制实现
       Object result = method.invoke(target, args);
       return result;
  }

   public void log(String methodName){
       System.out.println("执行了"+methodName+"方法");
  }

}

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色,不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService); //设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.add();
    }
}