04_框架基础之代理：跟着宝哥学Java：全网最详细：代理模式详解，静态代理、动态登录、cglib代理

1 概念

代理：代理模式 23种设计模式之一
    通过代理对象实现对被代理对象的功能进行增强和扩展
    类似于：代理商 中介
    代理对象：房屋中介
    被代理对象：买房/卖房
    原则：代理对象不能比被代理对象更多的功能
    使用：使用场景：日志信息 权限管理 流量统计 异常处理...

2 静态代理

好处：易于理解
坏处：通用性差::只能代理指定接口的实现类

public class Demo01StaticProxy {
     public static void main(String[] args) {
		//5 使用时：通过代理对象 来简介调用被代理对象的功能
    	 Student01  ss=new Student01("韩梅梅",11);//被代理对象
    	 
    	 Student01Proxy sproxy=new Student01Proxy(ss);
    	 sproxy.hehe();
    	 System.out.println(" -------------");
    	 System.out.println("结果="+sproxy.add(1, 2));
	}
}
//2 创建代理类
//1 必须为被代理类提取接口
interface Student01Inter{
	public void hehe();
	public int add(int a,int b);
}
//2 创建代理类 实现被代理类的相同接口：：：就拥有共同的方法
class Student01Proxy implements Student01Inter{
	//3 代理对象方法的核心 还是被代理对象的代码：：定义引用记录被代理对象
	private Student01Inter s;
    //通过构造方法参数列表 与被代理对象关联
	public Student01Proxy(Student01 s) {this.s = s;}

	
	//4 实现接口的所有方法：方法核心还是调用被代理对象的功能
	public void hehe() {
		//在核心代码之前扩展
		System.out.println(s+"的hehe方法要被调用前：");
		s.hehe();
		//在核心代码之后扩展
		System.out.println(s+"的hehe方法要被调用后：");
	}
	public int add(int a, int b) {
		System.out.println(s+"的add方法要被调用前：");
		int result=s.add(a,b);
		System.out.println(s+"的add方法要被调用后：");
		return result;
	}
	
	
}
class Student01 implements Student01Inter{
	private String name;
	private int age;
	public Student01(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void hehe(){
		System.out.println("我是student01：："+name+":"+age);
	}
	public int add(int a,int b){
		System.out.println("计算："+a+"+"+b);
		return a+b;
	}
}

3 动态代理/jdk代理

通过jdk的Proxy类的api  在运行时：动态的创建一个被代理对象的接口的实现类对象
优点：一个代理工厂类为任意被代理对象创建代理类对象
缺点：但被代理对象必须实现接口

public class Demo02DynamicProxy {

	public static void main(String[] args) {
		//7 创建被代理对象
		Student02 s2=new Student02("韩梅梅", 12);
		Teacher02 t2=new Teacher02();
		
		//8 创建代理工厂对象并与被代理对象关联
		ProxyFactory02 p2=new ProxyFactory02();
		p2.setTarget(s2);
		
		//9 通过工厂对象的newInstance方法获取代理对象
		Student02Inter proxy2=(Student02Inter)p2.newInstance();
		proxy2.hehe();
	   	System.out.println(" -------------");
	   	System.out.println("结果="+proxy2.add(1, 2));
	   	System.out.println(" -------------");
	   	
	   	//同一个工厂对象 可以代理不同接口的实现类 只要关联的对象不同即可
	   	p2.setTarget(t2);
	   	//注意：获取的代理对象的类型 必须是被代理对象的接口类型
	   	Teacher02Inter proxyt2=(Teacher02Inter)p2.newInstance();
		proxyt2.show();
		
		

	}
}
//1 创建被代理类
class Student02  implements Student02Inter{
	private String name;
	private int age;
	public Student02(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void hehe(){
		System.out.println("我是student02：："+name+":"+age);
	}
	public int add(int a,int b){
		System.out.println("我是student02：：计算："+a+"+"+b);
		return a+b;
	}
}
//2 提取被代理类的接口
interface Student02Inter{
	public void hehe();
	public int add(int a,int b);
}
interface Teacher02Inter{
	public void show();
}
class Teacher02 implements Teacher02Inter{
	public void show(){
		System.out.println("show方法：：：");
	}
}
//3 创建代理对象的工厂类::实现接口InvocationHandler：：通过方法创建代理对象
class ProxyFactory02 implements InvocationHandler{
	//4 定义引用来接口被代理对象
	private Object obj;
	//定义一个方法 给代理对象关联
	public void setTarget(Object obj) {
		this.obj = obj;
	}
	//5 定义一个方法 在运行时动态创建被代理对象相同接口的实现类对象作为代理对象
	public Object newInstance(){
		//newProxyInstance:作用：在运行时动态创建被代理对象的接口的实现类
		//参数1：被代理对象的类加载器
		//参数2：被代理对象的接口
		//参数3：InvocationHandler的实现类对象：：代理工厂类对象
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}
	//6实现调用代理对象的方法时 来调用代理对象的方法：：：对被代理对象功能的扩展
	//代理对象的任何方法被调用 此invoke方法就会调用 
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//被代理对象功能调用前扩展的代码
		System.out.println(obj+"的方法名是："+method.getName()+",参数列表是："+Arrays.toString(args)+"::方法被调用前！");
		Object result=method.invoke(obj, args);
		System.out.println(obj+"的方法名是："+method.getName()+",参数列表是："+Arrays.toString(args)+"::方法被调用后！");
		return result;
	}
}

4 cglib代理

通过spring的cglib的jar包来实现动态代理：：在运行时 创建一个被代理对象的子类对象
要求：被代理对象类不能是fianl即可

package com.zhiyou100.demo014_proxy;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class Demo03CglibProxy {
	public static void main(String[] args) {
		//7 创建被代理对象
		Student03 s3=new Student03("呵呵", 14);
		Teacher03 t3=new Teacher03();
		
		//8 创建代理对象工厂类对象 并与被代理对象关联
		ProxyFactroy03 proxyFactroy03=new ProxyFactroy03();
		proxyFactroy03.setTarget(s3);
		
		//9 获取代理对象
		Student03 proxy31=(Student03)proxyFactroy03.newInstance();
		proxy31.hehe();
	   	System.out.println(" -------------");
	   	System.out.println("结果="+proxy31.add(1, 2));
	   	System.out.println(" -------------");
	   	
	   	proxyFactroy03.setTarget(t3);
	   	Teacher03 proxy32=(Teacher03)proxyFactroy03.newInstance();
		proxy32.show();
		
		//注意：IllegalArgumentException: Superclass has no null constructors but no arguments were given
		// 被代理对象 必须有无参数的构造方法
		
	}
	

}
// 1 导入jar包：spring-core-3.2.18.RELEASE.jar
// 2 创建任意类：作为被代理类
class Student03{
	private String name;
	private int age;
	public Student03(String name, int age) {this.name = name;this.age = age;}
	public void hehe(){
		System.out.println("我是student02：："+name+":"+age);
	}
	public int add(int a,int b){
		System.out.println("我是student02：：计算："+a+"+"+b);
		return a+b;
	}
	public Student03() {}
	
}
class Teacher03 implements Teacher02Inter{
	public void show(){
		System.out.println("show方法：：：");
	}
}
// 3 创建代理对象工厂类：实现接口MethodInterceptor
class ProxyFactroy03 implements MethodInterceptor{
	//4 定义引用 记录被代理对象
	private Object target;
	//通过方法给被代理对象引用赋值
	public void setTarget(Object obj){
		this.target=obj;
	}
	//5 创建方法获取代理对象：：：被代理对象的子类对象
	public Object newInstance(){
		//工具类
        Enhancer en = new Enhancer();//创建一个增强工具类对象
        //设置父类
        en.setSuperclass(target.getClass());
        //设置回调函数的对象
        en.setCallback(this);
        //创建代理对象---是目标类的子类对象
        return en.create();
	}

	//6 代理对象的方法实现对被代理对象功能的控制
	//参数1：arg0代理对象
	//参数2：method被代理对象的方法
	//参数3：arg2被代理对象的方法的参数列表
	//参数4：arg3被代理对象方法的代理
	public Object intercept(Object arg0, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
		//System.out.println("arg0="+arg0);
		//被代理对象功能调用前扩展的代码
		System.out.println(target+"的方法名是："+method.getName()+",参数列表是："+Arrays.toString(arg2)+"::方法被调用前！");
		Object result=method.invoke(target, arg2);
		System.out.println(target+"的方法名是："+method.getName()+",参数列表是："+Arrays.toString(arg2)+"::方法被调用后！");
        System.out.println("arg3.getSuperName()::"+arg3.getSuperName());
		return result;
	}
}