静态代理和动态代理学习

静态代理学习:

目标对象和代理对象共同实现的接口

package staticproxy;

public interface TargetInterface {
    //说话的方法
    public void say();
    //吃饭的方法
    public void eat();
}

目标类

package staticproxy;
//目标对象
public class Target implements TargetInterface {

    @Override
    public void say() {
        System.out.println("人们会说话沟通");
    }

}

代理类:代理对象负责在目标对象的方法执行前后执行代理对象自己的代码;

需要实现目标对象所实现的统一接口

package staticproxy;
public class Proxytarget implements TargetInterface{
    private Target target;
    //创建静态代理类的构造方法,将目标对象传入到代理类中
    public Proxytarget(Target target){
        this.target=target;
    }
    @Override
    public void say() { 
        //添加代理的代码
        System.out.println("人们需要学习语言");
        
        //执行真实类需要执行的方法
        target.say();
        
        //添加代理的代码
        System.out.println("话不能随便乱讲,会伤害到人");
    }

 }

测试类:

import org.junit.Test;

public class TestDeom {
    @Test
    public void test1(){
        //创建目标对象
        Target target = new Target();
        //创建代理类,并将目标对象传递给代理类
        Proxytarget proxytarget = new Proxytarget(target);
        //代理类代用方法
        proxytarget.say();
    }

}

动态代理:

接口:

package dynProxy;

public interface ITarget {
    
    public void  method1();
    public void  method2();
}

目标类:

package dynProxy;
public class Target implements ITarget{

  @Override
    public void method1() {
        System.out.println("目标对象--->执行转入金钱的操作");
    }
    @Override
    public void method2() {
        System.out.println("目标对象--->执行转出金钱的操作");
    }
}
动态代理实现类:

package dynProxy;

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

import org.junit.Test;

public class DynProxy {
    /*动态代理执行流程:
    1,客户端调用method1方法,执行被InvocationHanalder拦截;
    2,在invoke方法中执行添加的额外的逻辑;
    3,调用m.invoke(target,args)执行到了真实的目标对象上的对应方法;
    4,真实对象返回执行结果到InvocationHandler里面;
    5,执行完成其他逻辑,把结果返回给客户端;
    */

    @Test
    public void test() {
        // java.lang.reflect.Proxy: 提供用于创建动态代理类和实例的静态方法
        // newProxyInstance()方法:返回一个指定接口的代理类实例;
        // loader: 指定要创建的代理类的类加载器;保持和目标对象相同
        // interfaces: 指定目标对象实现的接口;
        // InvocationHandler:指定自定义的代理逻辑实现类;
        ITarget proxy = (ITarget) Proxy.newProxyInstance(
                Target.class.getClassLoader(), 
                new Class[] { ITarget.class }, 
                new InvocationHandler() {
                    // invoke:代理对象执行的方法
                    // proxy: 在其上调用方法的代理实例;
                    // method:目标对象的方法字节码对象.
                    // agrs:目标对象中被调用方法的参数数组.
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开启事务");
                        // invoke中 Object obj:目标对象的实化对象
                        Object result = method.invoke(new Target(), args);
                        System.out.println("提交事务");
                        // 方法的返回值
                        return result;
                    }
                }
        );
        proxy.method1();
    }
}