动态代理的介绍

关于动态代理的操作

一、关于动态代理。

    1.动态代理：只学一个方法　方法的作用：在运行时，动态创建一组指定的接口的实现类对象！（在运行时，创建实现了指定的一组接口的对象）

2.动态代理的方法：Object proxyObject = Proxy.newProxyInstance(ClassLoader classLoader, Class[] interfaces, InvocationHandler h);

 方法作用：动态创建实现了interfaces数组中所有指定接口的实现类对象！
参数：
① ClassLoader：类加载器！
* 它是用来加载器的，把.class文件加载到内存，形成Class对象！
②Class[]　interfaces：指定要实现的接口们
③InvocationHandler：代理对象的所有方法(个别不执行，getClass())都会调用InvocationHandler的invoke()方法。

3.动态代理作用：最终是学习AOP（面向切面编程，这个会在spring里面详细介绍），它与装饰者模式有点相似，它比装饰者模式还要灵活！

4.详细介绍InvocationHandler：

InvocationHandler有一个抽象方法为invoke

public Object invoke(Object proxy, Method method, Object[] args);

这个invoke()方法在什么时候被调用！
①. 在代理对象被创建时?错误的！
②. 在调用代理对象所实现接口中的方法时?正确的！

* Object proxy：当前对象，即代理对象！在调用谁的方法！
* Method method：当前被调用的方法（目标方法）
* Object[] args：实参！

关于动态代理的对象调用接口中的有参数方法时在inovke方法中有个怎么样的对应方式

 

测试的代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

public class Demo01 {
    
    @Test
    public void fun01(){
    
    ClassLoader classLoader =this.getClass().getClassLoader();
    InvocationHandler invocationHandler =new InvocationHandler() {
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            System.out.println("动态代理被调用了");
            return "xxx";
        }
    };
    
    Object proxyobject = Proxy.newProxyInstance(classLoader, new Class[]{A.class,B.class},invocationHandler );
    A a = (A) proxyobject;
    B b = (B) proxyobject;
    a.a();
    b.b();
    proxyobject.toString();
    proxyobject.getClass();//这个方法不会调用invoke为啥，点进去看看Object,发现getClass()方法前面有native修饰表示这个方法为本地方法
    //带有native的都是为本地方法
    //proxyobject.equals(null);
    Object result=a.aaa("hello", 1000);
    System.out.println(result);//null xxx
    }
}
interface A{
    public void a();
    public Object aaa (String str,int i);
}
interface B{
    public void b();
}

 

根据上面的应用我们来写一个小例子：在一个Waiter类的serve方法的前后加上"你好"、"再见"

Waiter接口代码如下：

package cn.itcast.demo.proxy2;

public interface Waiter {
  public void serve();
}

 

 

Waiter实现类ManWaiter代码如下：

package cn.itcast.demo.proxy2;

public class ManWaiter  implements Waiter{
    @Override
    public void serve() {
    System.out.println("服务中...");
        
    }

}

 

操作动态代理的测试类代码如下：

package cn.itcast.demo.proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

/**
 * 我们必须要掌握这个案例的东西
 * @author 希
 *
 */
public class Demo01 {
        @Test
        public void fun01(){
            Waiter waiter =new ManWaiter();
            //为了得到代理对象首先准备三个参数
            ClassLoader classLoader =this.getClass().getClassLoader();//本类的类加载器
            Class[] interfaces = {Waiter.class};//代理的对象
            InvocationHandler invocationHandler =new ManWaiterHandler( waiter);
                
            Waiter  waiterProxy =(Waiter) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
            waiterProxy.serve();//代理对象调用增强后的内容
        }
}
class ManWaiterHandler implements InvocationHandler{
    private Waiter waiter ;
    public ManWaiterHandler(Waiter waiter){//创建一个有参构造让别人提供目标对象
        this.waiter=waiter;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("您好");
        this.waiter.serve();
        System.out.println("再见！");
        return null;
    }
    
}

 

上面的例子中是在invoke方法中添加了两条打印语句对目标方法进行了增强，但是这个样是把目标对象和增强的内容写死了我们不能硬编码

所以根据有上面的例子我们进行修改：

关于目标对象可以不用修改和上面一样

将增强的内容用接口表示出来当要获取代理对象时向里面加入这个接口的实例即可：

public interface AfterAdvice {
    public void after();

}

 

public interface BeforeAdvice {
  public void before();
}

 

然后我们创建一个得到代理对象的工厂：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;



/**
* 1.给定代理工厂
* 2.给定工厂设置三样东西：
* *目标对象setTargetObject(代理的对象的实例)
* *前置增强setBeforeAdivce(该接口的实现)
* *后置增强setAfterAdivce(该接口的实现)
* 3.调用createProxyObject()//得到最后的代理对象
* *执行代理对象方法时
* 》执行BeforeAdivce的before()方法具体的实现内容由该接口的实现决定
* >目标对象的目标方法
* 》执行AfterAdivce的before()方法具体的实现内容由该接口的实现决定
*/
public class ProxyFactory {
    private Object tagertObject;
    private BeforeAdvice beforeAdvice;
    private AfterAdvice  afterAdvice;
    
 public Object crateProxyObject(){
    //准备获得代理的三个参数
     ClassLoader classLoader =this.getClass().getClassLoader();
     Class[] interfaces=  tagertObject.getClass().getInterfaces();
     InvocationHandler  invocationHandler =new InvocationHandler() {
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //在这里填写代理内容
            //执行前置增强
            if(beforeAdvice!=null){
            beforeAdvice.before();
            }
            Object result=method.invoke(tagertObject, args);
            //执行后置增强
            if(beforeAdvice!=null){
            afterAdvice.after();
            }
            return result;
        }
    };
     Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
     
     return proxyObject;
     
 }
    
    
    
    
    
    public Object getTagertObject() {
        return tagertObject;
    }
    public void setTagertObject(Object tagertObject) {
        this.tagertObject = tagertObject;
    }
    public BeforeAdvice getBeforeAdvice() {
        return beforeAdvice;
    }
    public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
        this.beforeAdvice = beforeAdvice;
    }
    public AfterAdvice getAfterAdvice() {
        return afterAdvice;
    }
    public void setAfterAdvice(AfterAdvice afterAdvice) {
        this.afterAdvice = afterAdvice;
    } 

}

最后的测试类，来测试代理工厂是否可以得到代理对象并调用代理对象的方法：

我们需要向工厂传递：目标对象，前后置增强接口的实现 

最后直接将代理对象强转为目标对象类型这样调用目标对象的方法时都会先调用invoke方法

import org.junit.Test;


/**
 * 使用动态代理
 * @author 希
 *
 */
public class Demo01 {
    
    @Test
    public void fun01(){
    //第一步得到代理工厂的对象来设置目标对象和前置增强后置增强
    ProxyFactory factory =new ProxyFactory();//创建工厂
    factory.setBeforeAdvice(new BeforeAdvice() {//设置前置增强
        
        @Override
        public void before() {
        System.out.println("您好！");
            
        }
    });
    
    
    factory.setAfterAdvice(new AfterAdvice() {    //设置后置增强    
        @Override
        public void after() {
            System.out.println("再见！！");
            
        }
    });
    
    factory.setTagertObject(new ManWaiter());//给定目标对象
    Waiter waiter=(Waiter) factory.crateProxyObject();
    waiter.serve();
    waiter.pay();
    }
}

我们进行这样的修改后可以发现目标对象和增强的内容都可以替换，目标的装配工作是我们自己手打的，后期会由配置文件来做装配代理对象所需要的东西的工作

 

 

 

 

动态代理的主要结构如图所示：

目标对象：被增强的对象
代理对象：需要目标对象，然后在目标对象上添加了增强后的对象！
目标方法：增强的内容

代理对象 = 目标对象 + 增强

5.关于类加载器的简单介绍：