JDK动态代理(介绍理解，如何实现)
动态代理（理解）： 基于反射机制
1.什么是动态代理 ？
使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。
动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。
jdk动态代理，必须有接口，目标类必须实现接口， 没有接口时，需要使用cglib动态代理
2.知道动态代理能做什么 ？
可以在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码。程序开发中的意思。
比如：你所在的项目中，有一个功能是其他人（公司的其它部门，其它小组的人）写好的，你可以使用。
-----GoNong.class , GoNong gn = new GoNong(), gn.print();
你发现这个功能，现在还缺点， 不能完全满足我项目的需要。 我需要在gn.print()执行后，需要自己在增加代码。
用代理实现 gn.print（）调用时， 增加自己代码， 而不用去改原来的 GoNong文件。
在开发中也会有这样的情况， 你有a类， 本来是调用c类的方法， 完成某个功能。 但是c不让a调用。
a -----不能调用 c的方法。
在a 和 c 直接 创建一个 b 代理， c让b访问。
a --访问b—访问c
实际的例子： 登录，注册有验证码， 验证码是手机短信。
中国移动， 联通能发短信。
中国移动， 联通能有子公司，或者关联公司，他们面向社会提供短信的发送功能
张三项目发送短信----子公司，或者关联公司-----中国移动， 联通
3.使用代理模式的作用
- 功能增强： 在你原有的功能上，增加了额外的功能。 新增加的功能，叫做功能增强。
- 控制访问： 代理类不让你访问目标，例如商家不让用户访问厂家。
4.实现代理的方式
1.静态代理 ：
- 代理类是自己手工实现的，自己创建一个java类，表示代理类。
- 同时你所要代理的目标类是确定的。
- 特点：1）实现简单 2）容易理解。
- 缺点：
- 当你的项目中，目标类和代理类很多时候，有以下的缺点：
1）当目标类增加了， 代理类可能也需要成倍的增加。 代理类数量过多。
2）当你的接口中功能增加了， 或者修改了，会影响众多的实现类，厂家类，代理都需要修改。影响比较多。
- 当你的项目中，目标类和代理类很多时候，有以下的缺点：
例：模拟一个用户购买u盘的行为。
-
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。 -
三者的关系： 用户（客户端）—商家（代理）—厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。 -
实现步骤：
1. 创建一个接口，定义卖u盘的方法， 表示你的厂家和商家做的事情。
2. 创建厂家类，实现1步骤的接口
3. 创建商家，就是代理，也需要实现1步骤中的接口。
4. 创建客户端类，调用商家的方法买一个u盘。 -
代理类完成的功能：
1. 目标类中方法的调用
2. 功能增强
代码实现：
接口
// 表示功能的，厂家，商家都要完成的功能
public interface UsbSell {
//定义方法 参数 amount:表示一次购买的数量，暂时不用
//返回值表示一个u盘的价格。
float sell(int amount);
//可以多个其它的方法
//void print();
}
厂家
//目标类： 金士顿厂家, 不接受用户的单独购买。
public class UsbKingFactory implements UsbSell {
@Override
public float sell(int amount) {
System.out.println("目标类中的方法调用 , UsbKingFactory 中的sell ");
//一个128G的u盘是 85元。
//后期根据amount ，可以实现不同的价格，例如10000个，单击是80， 50000个75
return 85.0f;
}
}
//taobao是一个商家，代理金士顿u盘的销售。
public class TaoBao implements UsbSell {
//声明 商家代理的厂家具体是谁
private UsbKingFactory factory = new UsbKingFactory();
@Override
//实现销售u盘功能
public float sell(int amount) {
//向厂家发送订单，告诉厂家，我买了u盘，厂家发货
float price = factory.sell(amount); //厂家的价格。
//商家 需要加价， 也就是代理要增加价格。
price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
//在目标类的方法调用后，你做的其它功能，都是增强的意思。
System.out.println("淘宝商家，给你返一个优惠券，或者红包");
//增加的价格
return price;
}
}
买家
public class ShopMain {
public static void main(String[] args) {
//创建代理的商家taobao对象
TaoBao taoBao = new TaoBao();
//通过代理类，实现购买u盘，增加了优惠券，红包等等
float price = taoBao.sell(1);
System.out.println("通过淘宝的商家，购买u盘单价："+price);
｝
｝
2.动态代理
在静态代理中目标类很多时候，可以使用动态代理，避免静态代理的缺点。
1）代理类数量可以很少，
2）当你修改了接口中的方法时，不会影响代理类。
动态代理： 在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类。
换句话说： 动态代理是一种创建java对象的能力，让你不用创建TaoBao类，就能创建代理类对象。
在java中，要想创建对象：
- 创建类文件， java文件编译为class
- 使用构造方法，创建类的对象。
动态代理的实现：
-
jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。
反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy. -
cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。
cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中
重写父类中同名的方法， 实现功能的修改。
因为cglib是继承，重写方法，所以要求目标类不能是final的， 方法也不能是final的。
cglib的要求目标类比较宽松， 只要能继承就可以了。cglib在很多的框架中使用，
比如 mybatis ，spring框架中都有使用。
jdk动态代理
- 反射， Method类，表示方法。类中的方法。 通过Method可以执行某个方法。
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//使用反射机制执行sayHello方法。 核心Method（类中的方法）
HelloService target = new HelloServiceImpl();
//获取sayHello名称对于的Method类对象
Method method = HelloService.class.getMethod("sayHello", String.class);
//通过Method可以执行sayHello方法调用
/*
invoke是Method类中的一个方法。表示执行方法的调用
参数：
1. Object ， 表示对象的，要执行这个对象的方法,任意实现HelloService接口对象
2. Object... args ， 方法执行时的参数值
返回值：
Object：方法执行后的返回值
*/
HelloService service2 = new HelloServiceImpl2();
// 执行service2对象method（sayHello）方法，参数是“李四”
Object ret = method.invoke(service2, "李四");
}
- jdk动态代理的实现
反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.
1)InvocationHandler 接口（调用处理器）：就一个方法invoke（）
invoke（）:表示代理对象要执行的功能代码。你的代理类要完成的功能就写在
invoke()方法中。
方法原型：
public Object invoke(Object proxy, Method method, Object[] args){
}
参数：
----Object proxy: jdk创建的代理对象，无需赋值。
----Method method: 目标类中的方法，jdk提供method对象的
----Object[] args： 目标类中方法的参数， jdk提供的。
(1) InvocationHandler 接口：表示你的代理要干什么。
怎么用：
- 创建类实现接口InvocationHandler
- 重写invoke（）方法， 把原来静态代理中代理类要完成的功能，写在这。
(2) Method类：表示方法的， 确切的说就是目标类中的方法。
-
作用：通过Method可以执行某个目标类的方法，Method.invoke();
method.invoke(目标对象，方法的参数)
Object ret = method.invoke(service2, “李四”); -
说明： method.invoke（）就是用来执行目标方法的，等同于静态代理中的
//向厂家发送订单，告诉厂家，我买了u盘，厂家发货
float price = factory.sell(amount); //厂家的价格。
(3) Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()
现在我们是使用Proxy类的方法，代替new的使用。
- 方法： 静态方法 newProxyInstance()
作用是： 创建代理对象， 等同于静态代理中的TaoBao taoBao = new TaoBao();
参数：
- ClassLoader loader 类加载器，负责向内存中加载对象的。 使用反射获取对象的ClassLoader
类a , a.getCalss().getClassLoader(), 目标对象的类加载器 - Class[] interfaces： 接口， 目标对象实现的接口，也是反射获取的。
- InvocationHandler h : 我们自己写的，代理类要完成的功能。
返回值：就是代理对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
实现动态代理的步骤：
- 创建接口，定义目标类要完成的功能
- 创建目标类实现接口
- 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
1.调用目标方法
2.增强功能 - 使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。
动态代理实际代码：（两个类）
public class ServiceFactory {
public static Object getService(Object service){
//这里返回的是代理类对象
return new TransactionInvocationHandler(service).getProxy();
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.apache.ibatis.session.SqlSession;
public class TransactionInvocationHandler implements InvocationHandler{
private Object target;
public TransactionInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SqlSession session = null;
Object obj = null;
try{
session = SqlSessionUtil.getSqlSession();
obj = method.invoke(target, args);
session.commit();
}catch(Exception e){
session.rollback();
e.printStackTrace();
//处理的是什么异常，继续往上抛什么异常
throw e.getCause();
}finally{
SqlSessionUtil.myClose(session);
}
return obj;
}
public Object getProxy(){
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
}
}