静态代理和动态代理模式

一、代理模式

1、什么是代理模式

• 代理模式为对象提供一个代理以控制这个对象的访问

2、代理模式的本质

• 就是通过一个代码对象访问目标对象，而不直接访问目标对象

3、我们为什么要学习代理模式

• 因为aop的底层机制就是代理模式，但是他运用的是动态代理

4、静态代理

• 抽象角色：一般使用接口或者抽象类来实现
• 具体角色：被代理的角色
• 代理角色：代理真实角色
• 客户：使用代理角色来进行一些操作

5、好处

• 公共的业务由代理去完成，实现了业务的分工
• 在不改变原有基础代码情况上，实现了对原有功能的增强，这个就是AOP的核心思想

二、静态代理代码

1、例子一（增删改查业务）

• UserService

package test;
//抽象角色，做增删改查的业务
public interface UserService {
    void add();
    void delect();
    void update();
    void query();
}
 

• UserServiceImpl

package test;
//真实对象，完成增删改查的操作
public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }
 
    public void delect() {
        System.out.println("删除了一个用户");
    }
 
    public void update() {
        System.out.println("修改了一个用户");
    }
 
    public void query() {
        System.out.println("查询了一个用户");
    }
}
 

• UserServiceProxy

package test;
//代理角色，我们在代理角色这里去实现增加日志功能
public class UserServiceProxy implements UserService{
private UserServiceImpl userService;
 
    public UserServiceProxy() {
    }
 
    public UserServiceProxy(UserServiceImpl userService) {
        this.userService = userService;
    }
 
    public void add() {
        log();
        userService.add();
    }
 
    public void delect() {
        log();
        userService.delect();
    }
 
    public void update() {
        log();
        userService.update();
    }
 
    public void query() {
        log();
        userService.query();
    }
    public void log(){
        System.out.println("执行了日志功能");
    }
}
 

• User

package test;
 
public class User {
    public static void main(String[] args) {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
        userServiceProxy.add();
        System.out.println("-----------");
        userServiceProxy.delect();
        System.out.println("-----------");
        userServiceProxy.query();
        System.out.println("-----------");
        userServiceProxy.update();
    }
}
 

2、例子二（租房子业务）

• Rent

package pojo;
//抽象角色:租房
public interface Rent {
    public void rent();
}
 

• Host

package pojo;
//真实角色，房东需要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}
 

• Proxy

package pojo;
//代理角色:中介
public class Proxy implements Rent{
    private Host host;
 
    public Proxy(Host host) {
        this.host = host;
    }
 
    public Proxy() {
 
    }
 
    //租房
    public void rent() {
        seeHouse();//带房客看房子
        host.rent();//和房东签租房合同
        fare();//收取中介费
    }
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收取中介非
    public void fare(){
        System.out.println("收取中介费");
    }
}
 

• Clinet

package pojo;
//客户类，一般客户会去找房东
public class Clinet {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //中介要去帮助房东把房子租出去
        Proxy proxy = new Proxy(host);
 
        //客户需要去找到中介
        proxy.rent();
    }
}
 

三、动态代理

1、动态代理类是动态生成的，静态代理类是我们提前写好的

1、动态代理类可以分为两类：

1、一类是基于接口的动态代理

2、一类是基于类的动态代理

2、动态代理代码

• Rent

package dynamic;
 
public interface Rent {
    public void rent();
}
 

• Host

package dynamic;
 
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}
 

• PorxyInvocationHandler

package dynamic;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class PorxyInvocationHandler implements InvocationHandler {
    private Rent rent;
 
    public void setRent(Rent rent) {
        this.rent = rent;
    }
    //生成代理类，重点是第二个参数，获取要代理的抽象角色，之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }
    //proxy:代理类method:代理类的调用处理程序的方法对象
 
    //处理代理实例上的方法调用并返回结构
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心:本质上利用反射来实现
        Object invoke = method.invoke(rent, args);
        fare();
        return invoke;
    }
 
    public void seeHouse(){
        System.out.println("带租客看房");
    }
    public void fare(){
        System.out.println("收取中介费");
    }
}
 

• Client

package dynamic;
//客户类
public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        PorxyInvocationHandler porxyInvocationHandler = new PorxyInvocationHandler();
        //将真实角色放进去
        porxyInvocationHandler.setRent(host);
        //动态生成对应的代理类
        Rent rent = (Rent) porxyInvocationHandler.getProxy();
        rent.rent();
    }
}
 

__EOF__

本文作者：依然爱一天
本文链接：https://www.cnblogs.com/lovesz/p/16725203.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！