静态代理的理解及例子（租房模拟增删改查）

最新推荐文章于 2023-11-23 08:52:16 发布

qq_45929569

最新推荐文章于 2023-11-23 08:52:16 发布

阅读量199

点赞数 1

分类专栏：笔记文章标签：代理模式

本文链接：https://blog.csdn.net/qq_45929569/article/details/126431113

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

静态代理：

“静态代理:所谓静态代理也就是在程序运行前就已经存在代理类的字节码文件(在真正结婚之前,就已经做好了相关工作,婚庆公司和结婚的人就做好了相关联系)。代理模式就是在不修改被代理对象的基础上,通过扩展代理类,进行一些功能的附加与增强。简单来说静态代理就是在不改变源代码的基础上增加新的功能。

文字不好理解，还是用例子吧！
角色分析：

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

为了方便理解我们先看第一个例子：租房
在生活中，我们如果要去租房，理论上我们直接找房东就可以租到房子，但是现在我们不能直接找房东了，我们此时需要找中介，然后和中介去谈租房子的事，此时中介就相当于代理对象，如图：
在这里插入图片描述
例子的代码实现步骤：

1，抽象角色：接口（租房这件事）

2，真实角色（房东）

3，代理角色（中介）

4，客服访问代理角色（我）

1.抽象角色：（租房）Rent接口

package com.gues.dao;
//抽象角色 租房
public interface Rest {
    public void rest();
}

2，真实角色（房东）

package com.gues.dao;
//真实角色（房东） ----房东想要租房出去
public class Host implements Rent {
    public void rest() {
        System.out.println("房东想要出租房子========");
    }
}

按照正常情况的话，我们直接给房东租房子：

package com.gues.dao;

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

        host.rest();
    }
}

这样我们也可以实现租房，但现在我们需要找代理，而不是直接找房东，那么我们就引入代理对象中介，来实现我们不需要见到房东本人我们也能租到房子
3，代理角色（中介）

package com.gues.dao;

public class Proxy implements Rent{

    Host host = new Host();

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

    public void rest() {
        host.rest();
        seeHouse();
        heTong();
    }

    //这里面也可以附加自己的方法

    public void seeHouse(){
        System.out.println("中介带你看房子=====");
    }

    public void heTong(){
        System.out.println("中介和你签合同=========");
    }
}

4，客服访问代理角色（我）找中介租房找不到房东就找找中间商

package com.gues.dao;

public class Client {
    public static void main(String[] args) {

        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rest();
        //这里我们就实现了我找中介租房子，而不是直接找的房东
        //这里中介就是一个代理角色

    }
}

代理模式的好处：

可以使真实角色的操作更加纯粹！不在关注一些公共的事务
公共事务交给了代理角色去做！实现了业务的分工（代理角色（中介）拿钱就该办事）
公共业务发生扩展的时候，方便集中管理

缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率就会变低（动态代理就解决了这一缺点）

不懂就再理解这个例子：（CRUD）
例子：写增删改查业务时，需要给方法添加日志，此时我们应该怎么做在不修改原有代码的基础上给他添加日志呢？此时代理模式是最佳选择，在外面添加一个代理类，这样就不会修改到原有的代码，使已有代码变得更加安全

代码实现：
USerDao接口：

package com.gues.dao;

public interface UserDao {
    public void add();
    public void delete();
    public void update();
    public void select();
}

UserDaoImpl实现类

package com.gues.dao;

public class UserDaoImpl implements UserDao{
    public void add() {
        System.out.println("添加");
    }

    public void delete() {
        System.out.println("删除");

    }

    public void update() {
        System.out.println("修改");

    }

    public void select() {
        System.out.println("查询");

    }
}

service层：
UserService

package com.gues.dao.service;

import com.gues.dao.UserDao;
import com.gues.dao.UserDaoImpl;

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

UserServiceImpl

package com.gues.dao.service;

import com.gues.dao.UserDao;
import com.gues.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();
    public void add() {
        userDao.add();
    }

    public void delete() {
        userDao.delete();
    }

    public void update() {
        userDao.update();
    }

    public void select() {
        userDao.select();
    }
}

测试：

import com.gues.dao.service.UserService;
import com.gues.dao.service.UserServiceImpl;
import org.junit.Test;

public class MyTest {

    private UserService userService = new UserServiceImpl();

    @Test
    public void test01(){
        userService.add();
        userService.delete();
        userService.update();
        userService.select();
    }
}

运行结果：
在这里插入图片描述

此时我们模拟完成了增删改查操作，但是此时我需要你帮我添加一个业务，实现日志功能，但你不能修改我现在已有的代码，此时使用代理是个很好的选择：
创建代理对象：用来写日志功能：
Proxy

package com.gues.dao.service;

public class Proxy implements UserService{

    public void add() {
        log("add");
        System.out.println("执行了添加操作====");
    }

    public void delete() {
        log("delete");
        System.out.println("执行了删除操作====");

    }

    public void update() {
        log("update");
        System.out.println("执行了删除操作===");

    }

    public void select() {
        log("select");
        System.out.println("执行了查询操作===");

    }

    public void log(String msg){
        System.out.println(msg);
    }
}

测试：

import com.gues.dao.service.Proxy;
import com.gues.dao.service.UserService;
import com.gues.dao.service.UserServiceImpl;
import org.junit.Test;

public class MyTest {

    private UserService userService = new UserServiceImpl();
    Proxy proxy = new Proxy();

    @Test
    public void test01(){

        userService.add();
        proxy.add();

        userService.delete();
        proxy.delete();

        userService.update();
        proxy.update();

        userService.select();
        proxy.select();
    }
}