在之前的代码调用阶段，我们用action调用service的方法实现业务即可。
由于之前在service中实现的业务可能不能够满足当先客户的要求，需要我们重新修改service中的方法，但是service的方法不只在我们这个模块使用，在其他模块也在调用，其他模块调用的时候，现有的service方法已经能够满足业务需求，所以我们不能只为了我们的业务而修改service，导致其他模块授影响。
那怎么办呢？
可以通过动态代理的方式，扩展我们的service中的方法实现，使得在原油的方法中增加更多的业务，而不是实际修改service中的方法，这种实现技术就叫做动态代理。
动态代理：在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。
例如下面的例子：
1、 旧业务
买家调用action，购买衣服，衣服在数据库的标价为50元，购买流程就是简单的调用。
2、 新业务
在原先的价格上可以使用优惠券，但是这个功能在以前没有实现过，我们通过代理类，代理了原先的接口方法，在这个方法的基础上，修改了返回值。
代理实现流程：
1、 书写代理类和代理方法，在代理方法中实现代理Proxy.newProxyInstance
2、 代理中需要的参数分别为：被代理的类的类加载器soneObjectclass.getClassLoader()，被代理类的所有实现接口new Class[] { Interface.class }，句柄方法new InvocationHandler()
3、 在句柄方法中复写invoke方法，invoke方法的输入有3个参数Object proxy（代理类对象）, Method method（被代理类的方法）,Object[] args（被代理类方法的传入参数），在这个方法中，我们可以定制化的开发新的业务。
4、 获取代理类，强转成被代理的接口
5、 最后，我们可以像没被代理一样，调用接口的认可方法，方法被调用后，方法名和参数列表将被传入代理类的invoke方法中，进行新业务的逻辑流程。
上代码:
IBoss.java
/**
* 这是一个业务的接口，这个接口中的业务就是返回衣服的价格
* @author wilson
*
*/
public interface IBoss {//接口
int yifu(String size);
}
Boss.java
/**
* 实现了卖衣服的接口
* 自定义了自己的业务，卖裤子
* @author wilson
*
*/
public class Boss implements IBoss{
public int yifu(String size){
System.err.println("天猫小强旗舰店，老板给客户发快递----衣服型号："+size);
//这件衣服的价钱，从数据库读取
return 50;
}
public void kuzi(){
System.err.println("天猫小强旗舰店，老板给客户发快递----裤子");
}
}
SaleAction.java
public class SaleAction {
/**
* 不使用代理，直接调用方法
* 方法中规定什么业务，就只能调用什么业务，规定什么返回值，就只能输出什么返回值
*/
@Test
public void saleByBossSelf() throws Exception {
IBoss boss = new Boss();
System.out.println("老板自营！");
int money = boss.yifu("xxl");// 老板自己卖衣服，不需要客服，结果就是没有聊天记录
System.out.println("衣服成交价：" + money);
/*
程序输出:
天猫小强旗舰店，老板给客户发快递----衣服型号：xxl
老板自营！
衣服成交价：50
*/
}
}
使用动态代理:
ProxyBoss.java
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;
}
});
}
//写法二:在方法内部指定对象的Class
public 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;
}
}
调用动态代理:
ProxySaleAction.java
/**
* 什么是动态代理？ 简单的写一个模板接口，剩下的个性化工作，好给动态代理来完成！
*/
public class ProxySaleAction { /**
*使用代理，在这个代理中，只代理了Boss的yifu方法
*定制化业务，可以改变原接口的参数、返回值等
*/
@Test
public 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
*/
}
}
//==================另外一个总结=======================
上代码:
Waiter.java
public interface Waiter {
public void server();
public String sayHello(String name);
}
GirWaiter.java
public class GirlWaiter implements Waiter{
@Override
public void server() {
System.out.println("服务中………………");
}
@Override
public String sayHello(String name) {
return "Hello"+name;
}
}
ProxyDemo2.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; import org.junit.Test; public class ProxyDemo2 {
@Test
public 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.class Proxy.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张三
PS:之间总结的关于静态代理的博文