静态代理和动态代理的小demo

代理对象 = 增强代码 + 目标对象（原对象）

静态代理实现小demo

package javaNote.staticProxy;

public interface HelloService {
    public void say();
}

class HelloServiceImp implements HelloService {

    @Override
    public void say() {
        System.out.println("hello word");
    }
}
//-------------分割

package javaNote.staticProxy;

public class HelloServiceProxy implements HelloService {
    private HelloService target;

    public HelloServiceProxy(HelloService target) {
        this.target = target;
    }

    @Override
    public void say() {
        System.out.println("记录日志");
        target.say();
        System.out.println("清理数据");
    }
}
//-------------分割

package javaNote.staticProxy;

public interface HelloService {
    public void say();
}

package javaNote.staticProxy;

public class Main {
    public static void main(String[] args) {
        //目标对象
        HelloService target = new HelloServiceImp();
        //代理对象
        HelloServiceProxy proxy = new HelloServiceProxy(target);
        proxy.say();
    }
}

//输出的结果：
/**
 * 记录日志
 * hello word
 * 清理数据
 */

OK，现在已经被成为的代理了，这叫做静态代理，但是如果我们有很多的类，那么我们不是要写很多这样的demo，因为对于每个代理类，都要实现被代理类的接口：如图

所有就有了动态代理

创建对象的过程：

还有：之所有实现目标类和代理类实现相同的接口，是为了尽可能的保证代理类的内部结构和和目标类一致，这样就可以对代理的类的操作转移到目标对象的身上。

使用java.lang.reflect.InvocationHandler和java.lang.reflect.Method两个类实现代理，入口是proxy

proxy的一个静态方法：getProxy(ClassLoader, Interface)，传入类加载器和接口它就可以给你返回一个代理Class的对象，上图：

静态代理

动态代理

getProxyClass方法会从接口interface中拷贝结构信息到一个新的class对象中，而新的class对象有构造器，可以创建实例

1、目标类

package javaNote.dynamicProxy;

public class UserServiceImpl implements IUserService {
    @Override
    public void addUser() {
        System.out.println("新增了一个用户！");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除了一个用户！");
    }
}

interface IUserService {
    //添加用户
    public void addUser();
    //删除用户
    public void deleteUser();
}

2、代理类

package javaNote.dynamicProxy;

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

public class DynamicProxy implements InvocationHandler {
    private Object target;//被代理的对象

    public DynamicProxy(Object target) {
        this.target = target;
    }

    /**
     * proxy是生成的代理对象，method是代理的方法，args是方法接受的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("do something before ......");
        Object result = method.invoke(target, args);
        System.out.println("do something after......");
        return result;
    }
}

3、测试

package javaNote.dynamicProxy;

import java.lang.reflect.Proxy;

public class DynamicTest {
    public static void main(String[] args) {
        //被代理的类
        UserServiceImpl target = new UserServiceImpl();
        //将目标类和横切类编制在一起
        DynamicProxy handler = new DynamicProxy(target);
        //创建代理类的实例
        //第一个参数是类加载器，第二个参数是目标类所实现的一组接口，第三个是整合业务逻辑和横切逻辑的编辑器的对象
        IUserService proxy = (IUserService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
        proxy.addUser();
        proxy.deleteUser();
    }
}
//打印的结果
//do something before ......
//新增了一个用户！
//do something after......
//do something before ......
//删除了一个用户！
//do something after......