/*** 这是一个业务的接口，这个接口中的业务就是返回衣服的价格* @author wilson**/
public interface IBoss {//接口int yifu(String size);
}

/*** 实现了卖衣服的接口* 自定义了自己的业务，卖裤子* @author wilson**/
public class Boss implements IBoss{public int yifu(String size){System.err.println("天猫小强旗舰店，老板给客户发快递----衣服型号："+size);//这件衣服的价钱，从数据库读取return 50;}public void kuzi(){System.err.println("天猫小强旗舰店，老板给客户发快递----裤子");}
}

public class SaleAction {/*** 不使用代理，直接调用方法* 方法中规定什么业务，就只能调用什么业务，规定什么返回值，就只能输出什么返回值*/@Testpublic void saleByBossSelf() throws Exception {IBoss boss = new Boss();System.out.println("老板自营！");int money = boss.yifu("xxl");// 老板自己卖衣服，不需要客服，结果就是没有聊天记录System.out.println("衣服成交价：" + money);/*程序输出:天猫小强旗舰店，老板给客户发快递----衣服型号：xxl老板自营！衣服成交价：50*/}
}

public class ProxyBoss {/*** 对接口方法进行代理*/@SuppressWarnings("unchecked")//写法一:通过参数传入代理对象的Class ,更灵活,更方便的适配public static <T> T getProxy(final int discountCoupon,final Class<?> interfaceClass, final Class<?> implementsClass)throws Exception {return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),new Class[] { interfaceClass }, new InvocationHandler() {public Object invoke(Object proxy, Method method,Object[] args) throws Throwable {Integer returnValue = (Integer) method.invoke(implementsClass.newInstance(), args);// 调用原始对象以后返回的值return returnValue - discountCoupon;}});}//写法二:在方法内部指定对象的Classpublic static IBoss getProxyBoss(final int discountCoupon) throws Exception {Object proxedObj = Proxy.newProxyInstance(Boss.class.getClassLoader(),new Class[] { IBoss.class }, new InvocationHandler() {public Object invoke(Object proxy, Method method,Object[] args) throws Throwable {Integer returnValue = (Integer) method.invoke(new Boss(),args);// 调用原始对象以后返回的值return returnValue - discountCoupon;}});return (IBoss)proxedObj;}
}

/*** 什么是动态代理？ 简单的写一个模板接口，剩下的个性化工作，好给动态代理来完成！*/
public class ProxySaleAction {/***使用代理，在这个代理中，只代理了Boss的yifu方法*定制化业务，可以改变原接口的参数、返回值等*/@Testpublic void saleByProxy() throws Exception {/**  将代理的方法实例化成接口  10是要打折的价格数*  如下这种写法对应的是ProxyBoss.java中的public static <T> T getProxy(final int...这种方法*  IBoss boss = ProxyBoss.getProxy(10,IBoss.class,Boss.class);*///如下这种写法对应的是ProxyBoss.java中的public static IBoss getProxyBoss(final int 这种方法....IBoss boss = ProxyBoss.getProxyBoss(10);// 将代理的方法实例化成接口System.out.println("代理经营！");//调用接口的方法，实际上调用方式没有变 调用了invoke()方法int money = boss.yifu("xxl");System.out.println("衣服成交价：" + money);/*程序输出:代理经营！衣服成交价：40天猫小强旗舰店，老板给客户发快递----衣服型号：xxl*/}
}

public interface Waiter {public void server();public String sayHello(String name);}

public class GirlWaiter implements Waiter{@Overridepublic void server() {System.out.println("服务中………………");}@Overridepublic String sayHello(String name) {return "Hello"+name;}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;import org.junit.Test;public class ProxyDemo2 {@Testpublic void demo1(){//用当前的java类文件来获得ClassLoader对象.ClassLoader loader = ProxyDemo2.class.getClassLoader();//这是个数组,要用大括号括起来,而且返回的得到的是Class对象.Class[] interfaces = {Waiter.class}; /**loader - 定义代理类的类加载器      interfaces - 代理类要实现的接口列表h - 指派方法调用的调用处理程序newProxyInstance方法中需要传递三个参数:* loader:* interfaces:代理类要实现的接口列表* h:  h - 指派方法调用的调用处理程序* 应付一下:* ClassLoader:* Class[]返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于： Proxy.getProxyClass(loader, interfaces).getConstructor(new Class[] { InvocationHandler.class }).newInstance(new Object[] { handler });想为Waiter接口的一个实现类生成一个代理.就需要传入你这个类的实现接口的class.为什么是一个数组,一个类可以实现多个接口.想生成这个Waiter接口的代理类....传入Waiter.classProxy.newProxyInstance返回的是个Object类型,需要去强转MyInvocationHandler类中没有含有参数的构造方法,所以在new一个MyInvocationHandler的时候 一定要传入一个参数.这样才能编译通过.才能真正new出一个MyInvocationHandler对象. */    Waiter waiter = (Waiter) Proxy.newProxyInstance(loader, interfaces, new MyInvocationHandler(new GirlWaiter()));//调用waiter中的方法就相当域调用invoke的方法.
        waiter.server();String s = waiter.sayHello("张三");System.out.println(s);}
}//InvocationHandler 是代理实例的调用处理程序 实现的接口。
class MyInvocationHandler implements InvocationHandler{/*//在这个MyInvocationHandler的构造方法中传入一个GirlWaiter对象public MyInvocationHandler(GirlWaiter girlWaiter){}*//*对这个接口生成了一个代理类了....到底是生成一个接口的代理类还是生成这个接口的实现类的代理类....两个都可以,但是接口相当于其实现类的父类  但是接口更通用...所以一般都是生成接口的代理类.*/private Waiter waiter;public MyInvocationHandler(Waiter waiter){//传入参数的这个地方也用接口来做,更通用.this.waiter = waiter;}@Override/**不要忘记invoke()方法也是有参数的!!* invoke方法:*     * 调用waiter的某个方法都相当于调用invoke方法.*         * invoke方法的参数:*             * proxy:代理对象.*             * method:正在执行的方法.*             * args:方法的参数列表.*/public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {//只想增强一个固定的方法,方法名是固定的,通过if判断进行筛选.../** debug....* demo1中waiter.server() 的时候* method.getName = server ; args = null ; obj = null;* demo1中waiter.sayHello("张三");* method.getName = sayHello ; args = '张三' ; obj = "Hello张三"*/Object obj = null;if("server".equals(method.getName())){System.out.println("微笑");obj = method.invoke(waiter,args);}else{obj = method.invoke(waiter,args);}return obj;}
}

微笑
服务中………………
Hello张三