设计模式---动态代理简单实现以及思路

前言:

代理模式可以类比于歌手与经济人的关系，如果你想让歌手唱歌，那么通过经纪人就可以解决订票、签合同、唱歌(歌手唱歌)、收尾款等一些活动。

一、理论

代理模式(proxy pattern)

 核心角色：

      抽象角色:(歌手和经济人都是人)

         定义代理角色和真实角色的公共对外方法

     真实角色:（歌手）

          实现真实角色，定义真实角色所要实现的业务逻辑供代理角色调用

          关注真正的业务逻辑

     代理角色:

                实现抽象角色，是真实的角色代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作

               将统一的流程控制放到代理角色中处理

二、静态代理

一、类结构

1.  Star（抽象类或者结构--人）

   public interface Star {
   	/**订票*/
    void BookTicket();
    /**签合同
     * 
     * 
     * */
    void signContract();
    /*
     * 唱歌 (歌手能够唱歌，但是代理人不能唱歌)
     * 
     * 
     * */
     void sing();
     
     /*收尾款
      * 
      * 
      * */
      void  endMoney();
   }
   

2. SingStar(歌手）代码:

   //歌手实现了人接口
   public class SingStar  implements Star{
   
   	@Override
   	public void BookTicket() {
   		// TODO 自动生成的方法存根
   		System.out.print("订票了啊啊 ");
   	}
   
   	@Override
   	public void signContract() {
   		// TODO 自动生成的方法存根
   		System.out.println("签合同了 啊啊啊");
   		
   	}
   
   	@Override
   	public void sing() {
   		// TODO 自动生成的方法存根
   		System.out.println("周杰伦唱歌了");
   	}
   
   	@Override
   	public void endMoney() {
   		// TODO 自动生成的方法存根
   		System.out.println("收尾款");
   	}
   
   }
   

3. ProxyStar(代理人)代码:

   /**
    * @author zhangyang
    *
    */
   //经纪人的实现
   public class ProxyStar  implements Star{
       private Star star;//利用了组合关系
   	public ProxyStar(Star singstar) {
   		this.star = singstar;
   	}
   
   	@Override
   	public void BookTicket() {
   		// TODO 自动生成的方法存根
   	  System.out.println("代理人订票！");
   	}
   
   	@Override
   	public void signContract() {
   		// TODO 自动生成的方法存根
   		System.out.println("签合同！");
   	}
   
   	@Override
   	//调用的歌手唱歌的方法
   	public void sing() {
   		// TODO 自动生成的方法存根
   		star.sing();
   	}
   
   	@Override
   	public void endMoney() {
   		// TODO 自动生成的方法存根
   		System.out.println("代理人收尾款了");
   	}
   
   }

4. Client(客户)代码：

public class Client {
public static void main(String[] args) {
	  Star singstar=new SingStar();
	  Star proxystar=new ProxyStar(singstar);
	  //将他代理
	  proxystar.BookTicket();
	  proxystar.signContract();
	  proxystar.sing();
	  proxystar.endMoney();
}
}

      实现结果:

 二、动态代理

   动态代理在本质上使用了反射的机制。

 实现:

    一、类结构

1. Star代码(同上)

   //调用相关的抽象角色
   public interface Star {
    void bookTicket();
     void sing();
      void endMoney();
      
   }
   

    

2.  RealStart(歌手)

   public class RealStar  implements Star{
   
   	@Override
   	public void bookTicket() {
   		// TODO 自动生成的方法存根
   		System.out.println("歌手订票!");
   	}
   
   	@Override
   	public void sing() {
   		// TODO 自动生成的方法存根
   		System.out.println("歌手唱歌!");
   	}
   
   	@Override
   	public void endMoney() {
   		// TODO 自动生成的方法存根
   		System.out.println("歌手收尾款!");
   	}
   
   }
   

    

3. StartHandler(代理操作)

   public class StarHandler  implements InvocationHandler{
      private  Star realstar;
   	public StarHandler(Star realstar) {
   	super();
   	this.realstar = realstar;
   }
   	@Override
   	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   		// TODO 自动生成的方法存根
   		System.out.println("####");
   		//将自身的RealStar对象变成代理
   		method.invoke(realstar, args);
   		
   		return null;
   	}
   
   }

    

4. Client(客户)

import java.lang.reflect.Proxy;
import java.util.logging.Handler;

public class Client {
public static void main(String[] args) {
	 Star star=new RealStar();
	 StarHandler starHandler=new StarHandler(star);
	 //返回一个代理类，相当于经纪人
	Star star2=(Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] {Star.class}, starHandler);
	star2.bookTicket();
	star2.sing();
	star2.endMoney();
}
}

  实现结果:

调用的都是RealStar类对象的方法