关于java:JAVA基础之静态代理与动态代理

这个是陈腐的热乎的，针对某个面试题写了的内容，如果有问题欢送来喷。

来看看他们的区别

咱们先把动态代理和动静代理的代码放上来
看名字，这个是须要被代理的接口，无论是动态还是动静，都须要一个接口
ToBeProxyedInterface.java

public interface ToBeProxyedInterface {
    void addUser(String userId, String userName);
    void delUser(String userId);
    String findUser(String userId);
    void modifyUser(String userId, String userName);
}

上面是两个类，ToBeProxyedService1.java，ToBeProxyedService2.java，动态代理只须要一个就能够了，动静代理为了试验其动态性，所以来了两个具体的Service，后边能够看Client的main办法实现，如何指定1还是2的service调用
ToBeProxyedService1.java

public class ToBeProxyedService1 implements ToBeProxyedInterface {
    @Override
    public void addUser(String userId, String userName) {
        System.out.println("ToBeProxyedService1.addUser");
    }
    @Override
    public void delUser(String userId) {
        System.out.println("ToBeProxyedService1.delUser");
    }
    @Override
    public String findUser(String userId) {
        System.out.println("ToBeProxyedService1.findUser");
        return "张三";
    }
    @Override
    public void modifyUser(String userId, String userName) {
        System.out.println("ToBeProxyedService1.modifyUser");
    }
}

ToBeProxyedService2.class

public class ToBeProxyedService2 implements ToBeProxyedInterface {
    @Override
    public void addUser(String userId, String userName) {
        System.out.println("ToBeProxyedService2.addUser");
    }
    @Override
    public void delUser(String userId) {
        System.out.println("ToBeProxyedService2.delUser");
    }
    @Override
    public String findUser(String userId) {
        System.out.println("ToBeProxyedService2.findUser");
        return "张三2";
    }
    @Override
    public void modifyUser(String userId, String userName) {
        System.out.println("ToBeProxyedService2.modifyUser");
    }
}

重点来类，动态代理，通过构造方法传入了具体的须要代理的Service，因而每一个Handler只能代理一个Service，再减少一个Service时候，就须要在对应一个Handler，扩大不太好
StaticProxyHandler.java

public class StaticProxyHandler implements ToBeProxyedInterface {
    // 指标对象
    private ToBeProxyedService1 toBeProxyedService1;
    // 通过构造方法传入指标对象
    public StaticProxyHandler(ToBeProxyedService1 toBeProxyedService1){
        this.toBeProxyedService1=toBeProxyedService1;
    }
    @Override
    public void addUser(String userId, String userName) {
        try{
            //增加打印日志的性能
            //开始增加用户
            System.out.println("start StaticProxyHandler-->addUser()");
            toBeProxyedService1.addUser(userId, userName);
            //增加用户胜利
            System.out.println("success StaticProxyHandler-->addUser()");
        }catch(Exception e){
            //增加用户失败
            System.out.println("error StaticProxyHandler-->addUser()");
        }
    }
    @Override
    public void delUser(String userId) {
        toBeProxyedService1.delUser(userId);
    }
    @Override
    public String findUser(String userId) {
        toBeProxyedService1.findUser(userId);
        return "张三";
    }
    @Override
    public void modifyUser(String userId, String userName) {
        toBeProxyedService1.modifyUser(userId,userName);
    }
}

最重点来了，动静代理，能够在外面看不到任何具体的Service是哪个，具体的指定哪个Service在后边的Client的main办法传入指定不同的Service。实际上动静代理是通过实现了InvocationHandler实现的
具体看下，newProxyInstance办法是通过入参传入指定的具体的哪个Service的动静绑定，而Handler中实现InvocationHandler中的invoke办法，才是真正调用的具体的办法的实现。
DynamicProxyHandler.java

public class DynamicProxyHandler implements InvocationHandler {
    // 指标对象
    private Object targetObject;
    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些办法将被调用时，执行invoke办法。
    public Object newProxyInstance(Object targetObject){
        this.targetObject=targetObject;
        //该办法用于为指定类装载器、一组接口及调用处理器生成动静代理类实例
        //第一个参数指定产生代理对象的类加载器，须要将其指定为和指标对象同一个类加载器
        //第二个参数要实现和指标对象一样的接口，所以只须要拿到指标对象的实现接口
        //第三个参数表明这些被拦挡的办法在被拦挡时须要执行哪个InvocationHandler的invoke办法
        //依据传入的指标返回一个代理对象
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),this);
    }
    @Override
    //关联的这个实现类的办法被调用时将被执行
    /*InvocationHandler接口的办法，proxy示意代理，method示意原对象被调用的办法，args示意办法的参数*/
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("start DynamicProxyHandler--invoke >>");
        for(int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
        Object ret=null;
        try{
            /*原对象办法调用前解决日志信息*/
            System.out.println("satrt DynamicProxyHandler call method -->>");
            //调用指标办法
            ret=method.invoke(targetObject, args);
            /*原对象办法调用后处理日志信息*/
            System.out.println("success DynamicProxyHandler call method -->>");
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("error DynamicProxyHandler call method -->>");
            throw e;
        }
        return ret;
    }
}

上面的main办法能够看到，动态代理传入的就是具体的ToBeProxyedService1，无奈实现扩大
后边的动静代理我写了两遍，实际上每次传入的不同的ToBeProxyedService1和ToBeProxyedService2，别离都能够执行，不便动静扩大，后边如果再有ToBeProxyedService3，只有调用前批改就能够，不必批改具体的Handler，不便扩大了。
Client.java

public class Client {
    public static void main(String[] args){
        //动态代理，每一个固定写死了具体的须要代理的类
        StaticProxyHandler staticProxyHandler = new StaticProxyHandler(new ToBeProxyedService1());
        staticProxyHandler.addUser("1111", "张三");
        //动静代理，须要执行ToBeProxyedService1就传入ToBeProxyedService1，如果须要执行ToBeProxyedService2就传入ToBeProxyedService2
        DynamicProxyHandler proxyHandler=new DynamicProxyHandler();
        ToBeProxyedInterface service = (ToBeProxyedInterface) proxyHandler.newProxyInstance(new ToBeProxyedService1());
        service.addUser("1111", "张三");
        service = (ToBeProxyedInterface) proxyHandler.newProxyInstance(new ToBeProxyedService2());
        service.addUser("1111", "张三");
    }
}