代理的使用
1.代理
代购，中介，换ip，商家等等
比如一家美国大学，可以对世界招生，学校不可能直接招生，所以通过中介代替学校完成招生的功能，中介也称为学校的代理。
代理的特点：
1.中介和代理他们要做的事情是一致的：招生
2.中介是学校代理，学校是目标
3.家长--中介--（学校介绍，办入学手续）--美国学校
4.中介是代理，不能白干活，需要收取费用
5.代理不让你访问到目标
为什么要找中介？
1.因为中介是专业并且方便的
2.家长不能自己去寻找自己去找的学校。家长没有能力访问学校，美国学校不接受个人来访问
个人 --- 商家 --- 厂家
例如有一个商家，如果你想要买东西，你只能通过商家而不能直接通过厂家进行购买，所以说商家被称之为代理
2.开发中的代理
在开发中也会遇到这样的情况，你有a类，本来是调用c类的方法，完成某个功能。但是c不让a调用
a --- 不能调用c的方法
这时需要创建一个b代理，让a访问b
a --- 访问b --- 访问c
实际中的例子：登录，注册有验证码，验证码是手机短信
代理模式：
代理模式是指，为其他对象提供一种代理以控制对这个对象的访问，在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。
3.使用代理模式的作用
1.功能增强：在你原有的功能上，增加了额外的功能，新增加的功能，叫做功能增强
2.控制访问：代理类不让你访问目标，例如商家不让用户访问厂家
4.实现代理的方式
1.静态代理：
1）代理类是自己手工实现的，自己创建一个java类，表示代理类
2）同时你所要代理的目标类是确定的
特点： 1）实现简单 2）容易理解
缺点：
当你的项目中，目标类和代理类很多的时候，有以下的缺点：
1）当目标类增加了,代理类可能也需要成倍的增加。代理类数量多
2）当你的接口中功能增加了，或者修改了，会影响众多的实现类，厂家类，代理都需要修改。
影响比较多
模拟一个用户买U盘的例子：
分析 用户：是客户端类
商家：代理，代理某个品牌的U盘
厂家：目标类
三者的关系： 用户---商家---厂家
商家和厂家都是卖U盘的，他们完成的功能是一致的，都是卖U盘的
实现步骤：
1.创建一个接口，定义卖u盘的方法，表示你的厂家和商家做的事情
// 表示功能的，厂家，商家都要完成的功能
public interface UsbSell {
// 定义一个销售的方法
float Sell(int number);
}
2.创建厂家类，实现1步骤的接口
import service.UsbSell;
// 定义厂家的类并实现UsbSell接口
public class UsbKingFactory implements UsbSell {
// 重写接口中的方法，并返回u盘的价格
@Override
public float Sell(int number) {
// 返回价格
return 89.0f;
}
}
3.创建商家，就是代理，也需要实现1步骤中的接口
import factory.UsbKingFactory;
import service.UsbSell;
// 定义代理商家淘宝实现usb接口
public class TaoBao implements UsbSell {
// 重写
@Override
public float Sell(int number) {
// 创建厂家的对象通过调用厂家的销售方法，增加并提高利润功能
UsbKingFactory usb = new UsbKingFactory();
float price = usb.Sell(1);
// 淘宝商家通过厂家获得利润
price = price + 25;
// 返回增加后价格的u盘的价格
return price;
}
}
4.创建客户端类，调用商家的方法买一个u盘
import proxy.TaoBao;
public class ShopMain {
public static void main(String[] args) {
// 购买商品
// 客户端通过淘宝进行购买商品
// 创建淘宝商家的对象
TaoBao tb = new TaoBao();
float price2 = tb.Sell(1);
System.out.println("您已经购买成功花了:" + price2);
}
}
代理类完成的功能：
1.目标类中方法的调用
2.功能增强
2.动态代理：
动态代理（理解）：基于反射的机制
1.什么是动态代理？
使用jdk的反射机制，创建对象的能力，创建的是代理类的对象。而不用
创建类文件，不用写java文件。
动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。
jdk动态代理，必须有接口，目标类必须实现接口,没有接口的情况需要使用cglib动态代理
2.知道动态代理能做什么？
可以在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。
程序开发中的意思
在静态代理中目标类很多的时候，可以使用动态代理，避免静态代理的缺点。
动态代理中目标类即使很多 1）代理类数量可以很少 2）当你修改了接口中的方法
时，不会影响代理类。
动态代理：在程序执行过程中，使用jdk反射机制，创建代理类对象，并动态的指定
要代理目标类
换句话说：动态代理是一种创建java对象的能力，让你不用代理类，就能创建代
理类对象
动态代理的实现：
1.jdk动态代理（理解）：使用java反射包中的类和接口实现动态代理的功能。
反射包 java.lang.reflect,里面有三个类：InvocationHandler ,method ,Proxy
2.cglib动态代理：cglib是第三方的工具库，创建代理对象。
cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中
重写父类中同名的方法，实现功能的修改。
因为cglib是继承，重写方法，所以要求目标类不能是final的，方法也不能是final的，
cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，
比如mybatis，spring框架中都有使用。
jdk动态代理：
1.反射，Method类，表示方法。类中的方法，通过Method可以执行某个方法
2.jdk动态代理的实现
反射包 java.lang.reflect 里面有三个类：InvocationHandler,Method,Proxy
1)Invocationhandler接口（调用处理器）：就一个方法invoke（）
invoke（）：表示代理对象要执行的功能代码。你的代码类要完成的功能就写在invoke()方法
代理类完成的功能：
1.调用目标方法，执行目标方法的功能
2.功能增强，在目标方法调用是，增加功能
方法原型：
参数：Object proxy:jdk创建的代理对象，无需赋值 (jdk提供的)
Method method：目标类中的方法，jdk提供的method对象的
Object[] args:目标类中的方法的参数 (jdk提供的)
public object invoke(Object proxy, Method method,Object[] args)
InvocationHandler 接口：表示你的代理要干什么。
怎么用：1.创建类实现接口InvocationHandler
2.重写invoke（）方法，把原来静态代理中代理类要完成的功能，写在这里面
2）Method类：表示的方法，确切的说就是目标类中的方法。
作用：通过Method可以执行某个目标类的方法，Method.invoke();
method.invoke(目标对象，方法的参数)
Object ret = method.invoke(service2,"张三");
说明：method.invoke()就是用来执行目标的方法的，等同于静态代理中的
float price = factory.sell(amount);
3)Proxy类：核心的对象，创建代理对象。之前创建对象都是new类的构造方法（）
现在我们是使用Proxy类的方法，代替new的使用
方法：静态方法 newProxyInstance();
作用是：创建代理对象，等同于静态代理中的TaoBao taobao = new TaoBao();
参数:
1.ClassLoader loader类加载器，负责向内存中加载对象的。使用反射获取对象的
ClassLoader类a ，a.getClass().getClassLoader(),目标对象的类加载器
2.Class<?>[] interfaces: 接口，目标对象实现的接口，也是反射获取的
3.InvocationHandler h :我们自己写的，代理类要完成的功能
返回值：就是代理对象
public static object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
Invocationhandler h)
3.实现动态代理的步骤：
1.创建接口，定义目标类要完成的功能
public interface UsbSell {
// 定义一个卖u盘的接口
float Sell(int number);
}
2.创建目标类实现接口
import service2.UsbSell;
// 定义一个目标类，卖u盘的工厂
public class MuBiaoClass implements UsbSell {
// 重写销售的方法
@Override
public float Sell(int number) {
return 95.0f;
}
}
3.创建invocationhandler接口的实现类，在invoke方法中完成代理类的功能
1.调用目标方法
2.增强功能
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DaiLiClass implements InvocationHandler {
// 定义一个变量
private Object target = null;
// 定义一个构造方法
public DaiLiClass(Object target) {
this.target = target;
}
// 重写接口的方法进行代理操作（目标类中方法的调用，功能的增强）
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = null;
// 创建厂家的对象通过调用厂家的销售方法，增加并提高利润功能
// 第一个参数是目标类的对象，第二个参数是对象参数
invoke = method.invoke(target, args);
if(invoke != null){
// 使用包装类进行强转
Float price = (Float)invoke;
// 淘宝商家通过厂家获得利润
price = price + 25;
// 返回增加后价格的u盘的价格
invoke = price;
}
return invoke;
}
}
4.使用Proxy类的静态方法，创建代理对象。并把返回值转为接口类型
import factory.MuBiaoClass;
import proxy.DaiLiClass;
import service2.UsbSell;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class TestMain {
public static void main(String[] args) {
// 定义测试类
// 创建目标类的对象
UsbSell us = new MuBiaoClass();
// 创建代理类的对象
InvocationHandler dl = new DaiLiClass(us);
// proxy 是代理对象，是com.sun.proxy.$Proxy类型的
// 创建代理对象
UsbSell obj = (UsbSell)Proxy.newProxyInstance(us.getClass().getClassLoader(),
us.getClass().getInterfaces(),
dl);
// 代理对象进行调用
float price = obj.Sell(1);
System.out.println("动态代理的后购买为:" + price + "元");
}
}