java代理

代理：对对象的行为额外做一些辅助操作。

静态代理：了解设计模式中的代理模式的童鞋应该都知道，如果想要生成代理类，需要让代理类和被代理类实现同一个接口，并且在代理类中添加被代理类的引用，代理类方法实现中添加代理逻辑，并决定是否调用被代理类方法，这种通过硬编码的方式指定代理类与被代理类的方式，叫静态代理。可以明显看出，静态代理类与被代理类是强耦合的，如果要代理100个类，你就得写100个代理类

动态代理：其实动态代理与静态代理的本质一样，最终程序运行时都需要生成一个代理对象实例，通过它来完成相关增强以及业务逻辑，只不过静态代理需要硬编码的方式指定，而动态代理则是以动态方式生成代理(有编译时操作字节码生成的方式、运行时通过反射、字节码生成的方式)。动态生成的好处很明显，代理逻辑与业务逻辑是互相独立的，没有耦合，代理1个类或100个类要做的事情没有任何区别
下面通过举一个动态代理的例子：
接口：UserService：

package d10_proxy2;

public interface UserService {
    String login(String loginName,String password);
    void deleteUsers();
    String selectUsers();
}

接口的实现类：UserServiceImpl;

package d10_proxy2;

public class UserServiceImpl implements UserService{
    @Override
    public String login(String loginName, String password) {
       String rs="登录名和密码错误";
        if("admin".equals(loginName)&&"123456".equals(password))
        {
            rs="登录成功";
        }
       return rs;

    }

    @Override
    public void deleteUsers() {

        try {
            System.out.println("您正在删除用户数据。。。。");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }

    @Override
    public String selectUsers() {

        String rs="查询了10000个用户数据——————";
        try {
            System.out.println("您正在删除用户数据。。。。");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       return  rs;

    }
}

实现代理的工具类:ProxyUtil:

package d10_proxy2;

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

public class ProxyUtil {
    //通过一个静态方法，为用户业务对象返回一个代理对象
    public static UserService getProxy(final UserService obj)
    {

        return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long startTime =System.currentTimeMillis();

                        //真正触发对象的行为执行的
                       Object rs=  method.invoke(obj,args);
                        long endTime =System.currentTimeMillis();
                        System.out.println(method.getName()+"方法耗时:"+(endTime-startTime)+"s");
                        return rs;
                    }
                });
    }
}

测试类Test：

package d10_proxy2;

public class Test {
    public static void main(String[] args) {
        //目标：掌握实用代理解决问题，理解使用动态代理的优势
        UserService userService=ProxyUtil.getProxy(new UserServiceImpl());
        System.out.println(userService.login("admin","123456"));
        System.out.println(userService.selectUsers());
        userService.deleteUsers();
    }


}

执行结果：

优化的关键步骤：

动态代理的优点：