设计模式代理模式 ( 静态代理 )

Posted 2021-09-09 韩曙亮

文章目录

• 一、静态代理代码示例
• • 1、订单类
  • 2、Service 接口
  • 3、Service 实现类
  • 4、Service 静态代理类
  • 5、Dao 接口
  • 6、Dao 实现类
  • 7、测试类

一、静态代理代码示例

---

业务场景 : 保存订单信息 , 在 Service 层处理订单保存 , 在 Dao 层将订单存储到数据库 ; 使用静态代理类加强 Service 层的功能 ;

1、订单类

package proxy;

/**
 * 订单类
 *      存储订单时 , 通过 Service 层通接收 Order 对象进行处理
 */
public class Order {
    /**
     * 订单信息
     */
    private Object orderInfo;

    /**
     * 用户 ID
     */
    private Integer userId;

    public Order(Object orderInfo, Integer userId) {
        this.orderInfo = orderInfo;
        this.userId = userId;
    }

    public Object getOrderInfo() {
        return orderInfo;
    }

    public void setOrderInfo(Object orderInfo) {
        this.orderInfo = orderInfo;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }
}

2、Service 接口

package proxy;

/**
 * 服务接口
 */
public interface IOrderService {
    /**
     * 保存订单
     * @param order 数据库生效行数
     * @return
     */
    int saveOrder(Order order);
}

3、Service 实现类

package proxy;

public class OrderServiceImpl implements IOrderService {
    private IOrderDao iOrderDao;

    public OrderServiceImpl(IOrderDao iOrderDao) {
        this.iOrderDao = iOrderDao;
    }

    @Override
    public int saveOrder(Order order) {
        System.out.println("Service 层插入 Order 订单信息成功");
        return this.iOrderDao.insert(order);
    }
}

4、Service 静态代理类

package proxy;

/**
 * 订单服务静态代理类
 */
public class OrderServiceStaticProxy {
    private IOrderService iOrderService;

    public OrderServiceStaticProxy(IOrderService iOrderService) {
        this.iOrderService = iOrderService;
    }

    public int saveOrder(Order order){
        beforeMethod();
        int result = iOrderService.saveOrder(order);
        afterMethod();
        return result;
    }

    /**
     * 在被代理对象方法之前执行的内容
     */
    private void beforeMethod() {
        System.out.println("静态代理 OrderServiceStaticProxy 执行 saveOrder 之前");
    }

    /**
     * 在被代理对象方法之后执行的内容
     */
    private void afterMethod() {
        System.out.println("静态代理 OrderServiceStaticProxy 执行 saveOrder 之后");
    }
}

5、Dao 接口

package proxy;

/**
 * 数据库接口
 */
public interface IOrderDao {
    /**
     * 向数据库中插入订单信息
     * @param order
     * @return
     */
    int insert(Order order);
}

6、Dao 实现类

package proxy;

public class OrderDaoImpl implements IOrderDao {
    @Override
    public int insert(Order order) {
        System.out.println("Dao 层插入 Order 订单信息成功");
        return 1;
    }
}

7、测试类

package proxy;

public class Main {
    public static void main(String[] args) {
        Order order = new Order("书籍订单", 1);

        IOrderDao dao = new OrderDaoImpl();
        IOrderService service = new OrderServiceImpl(dao);

        // 不使用代理的情况
        service.saveOrder(order);

        System.out.println();

        // 使用代理的情况
        OrderServiceStaticProxy proxy = new OrderServiceStaticProxy(service);
        proxy.saveOrder(order);

    }
}

执行结果 :

Service 层插入 Order 订单信息成功
Dao 层插入 Order 订单信息成功

静态代理 OrderServiceStaticProxy 执行 saveOrder 之前
Service 层插入 Order 订单信息成功
Dao 层插入 Order 订单信息成功
静态代理 OrderServiceStaticProxy 执行 saveOrder 之后