代理模式01——静态代理

为什么要学习代理模式？——因为这就是SpringAOP的底层。

代理模式分类：

• 静态代理；
• 动态代理。

1、静态代理

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

1.1、示例一：

1. 编写抽象角色；

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

2. 编写真实角色；

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

3. 编写代理角色；

   package com.beyond.demo01;
   
   //代理
   public class Proxy implements Rent{
       private Host host;
   
       public Proxy() {
       }
   
       public Proxy(Host host) {
           this.host = host;
       }
   
       //代理帮房东出租房子
       public void rent() {
           seeHouse();
           host.rent();
           hetong();
           fare();
       }
   
       //代理独有的特点，看房,收中介费,签租赁合同
       public void seeHouse(){
           System.out.println("中介带你看房");
       }
       public void fare(){
           System.out.println("收中介费");
       }
       public void hetong(){
           System.out.println("签租赁合同");
       }
   }
   

4. 客户。

   package com.beyond.demo01;
   
   public class Client {
       public static void main(String[] args) {
           Host host=new Host();
   
           //代理
           Proxy proxy = new Proxy(host);
           //你不用面对房东，直接找中介即可
           proxy.rent();
       }
   }
   

静态代理模式的好处：

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

缺点：

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

1.2、示例二：

面向对象的七大原则

1. 编写抽象角色（接口）；

   package com.beyond.demo02;
   
   public interface UserService {
       public void add();
       public void delete();
       public void update();
       public void query();
   }
   

2. 编写真实角色（接口实现类）；

   package com.beyond.demo02;
   
   public class UserServiceImpl implements UserService{
       public void add() {
           System.out.println("增加一个用户");
       }
   
       public void delete() {
           System.out.println("删除一个用户");
       }
   
       public void update() {
           System.out.println("修改一个用户");
       }
   
       public void query() {
           System.out.println("查询一个用户");
       }
   }
   

3. 编写代理角色；

   package com.beyond.demo02;
   
   public class UserServiceProxy implements UserService{
       private UserServiceImpl userService;
   
       public void setUserServiceProxy(UserServiceImpl userService) {
           this.userService = userService;
       }
   
       public void add() {
           userService.add();
           log("add");
       }
   
       public void delete() {
           userService.delete();
           log("delete");
       }
   
       public void update() {
           userService.update();
           log("update");
       }
   
       public void query() {
           userService.query();
           log("query");
       }
   
       //日志方法
       public void log(String msg){
           System.out.println("使用了"+msg+"方法");
       }
   }
   

4. 客户。

   package com.beyond.demo02;
   
   public class Client {
       public static void main(String[] args) {
           UserServiceImpl userService = new UserServiceImpl();
   
           UserServiceProxy proxy = new UserServiceProxy();
           proxy.setUserServiceProxy(userService);
   
           proxy.add();
       }
   }