静态代理与动态代理理解

1.静态代理

其实就是一个典型的代理模式实现，在代理类中包装一个被代理对象，然后影响被代理对象的行为

代码示例：

// 接口
public interface Hello {

public void sayHello(String name);

}

// 实现类
@Slf4j
public class HelloImpl implements Hello {

    @Override
    public void sayHello(String name) {

//        log.info("----->HelloImpl:{}", name);

        System.out.println(">>>>>:HelloImpl" + name);

    }

}

/**
* @Auther: 18030501
* @Date: 2018/10/15 16:51
* @Description: 代理类
*/
@Slf4j
public class HelloProxy implements Hello {

private Hello hello;

    public HelloProxy(Hello hello) {

        this.hello = hello;

    }

    @Override
    public void sayHello(String name) {

        log.info("do sayHello before...");
        hello.sayHello(name);
        log.info("do sayHello after...");

    }

}

/**
* @Auther: 18030501
* @Date: 2018/10/15 16:56
* @Description: 静态代理测试
*/
public class TestHelloProxy {

public static void main(String[] args) {

        Hello hello =new HelloProxy(new HelloImpl());
        hello.sayHello("李峰");

    }

}

运行结果：

静态代理测试结果.png

2.动态代理

分类：JDK动态代理与CGLIB动态代理

JDK动态代理：

此时代理对象和目标对象实现了相同的接口，目标对象作为代理对象的一个属性，具体接口实现中，可以在调用目标对象相应方法前后加上其他业务处理逻辑。
代理模式在实际使用时需要指定具体的目标对象，如果为每个类都添加一个代理类的话，会导致类很多，同时如果不知道具体类的话，怎样实现代理模式呢？这就引出动态代理。JDK动态代理只能针对实现了接口的类生成代理！

代码示例：

/**
 * @Auther: 18030501
 * @Date: 2018/10/15 17:23
 * @Description: 接口
 */
public interface UserService {
    public abstract void login(String name);
    void logout(String name);
}

/**
 * @Auther: 18030501
 * @Date: 2018/10/15 17:23
 * @Description: 实现类
 */
@Slf4j
public class UserServiceImpl implements UserService {

    @Override
    public void login(String name) {
        log.info("{} login...", name);
    }

    @Override
    public void logout(String name) {
        log.info("{} logout...", name);
    }
}

/**
 * @Auther: 18030501
 * @Date: 2018/10/15 17:24
 * @Description: 增强的类
 */
@Slf4j
public class UserServiceHandler implements InvocationHandler {

    private UserService userService;

    public UserServiceHandler(UserService userService) {
        this.userService = userService;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 执行前可以做点什么
        log.info("before do method...");
        // 执行被代理类的方法
        Object obj = method.invoke(userService, args);
        // 执行后可以做点什么
        log.info("after do method...");
        return obj;
    }
}

/**
 * @Auther: 18030501
 * @Date: 2018/10/15 17:27
 * @Description: JDK动态代理
 */
public class ProxyFactory {

    public static void main(String[] args) throws Exception {
        UserService userService = new UserServiceImpl();
        UserService obj = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new UserServiceHandler(userService));
        obj.login("李峰");
        // 输出代理类的class文件
//        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{userService.getClass()});
//        FileOutputStream os = new FileOutputStream("Proxy0.class");
//        os.write(bytes);
//        os.flush();
//        os.close();
//        obj.logout();
//        userService.logout();
    }

运行结果：

JDK动态代理运行结果.png

CGLIB动态代理：

CGLIB代理是针对类实现代理，
主要是对指定的类生成一个子类，覆盖其中的所有方法，使用的是继承的方式，所以该类或方法不能声明称final的。
CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过
CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程

代码示例：

/**
 * @Auther: 18030501
 * @Date: 2018/10/15 19:08
 * @Description: CGLIB动态代理
 */
@Slf4j
public class ProxyFactory2 implements MethodInterceptor {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        ProxyFactory2 proxyFactory2 = new ProxyFactory2();
        UserService proxyObject = proxyFactory2.getProxyObject(userService.getClass());
        proxyObject.login("李峰");
    }


    // 提供对应的增强操作类
    private Enhancer enhancer = new Enhancer();

    public UserService getProxyObject(Class clazz) {
        // 设置所要增强的类的父类
        enhancer.setSuperclass(clazz);
        // 设置回调对象
        enhancer.setCallback(this);
        // 创建对应的对象
        return (UserService) enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        log.info("do before....");
        // 这里需要注意，由于methodProxy对象是增强后的Method对象，所以这里需要调用的
        // 是methodProxy父类的方法，也就是所要增强的类的方法，以实现原来的功能
        Object obj = methodProxy.invokeSuper(o, objects);
        log.info("do after....");
        return obj;
    }
}

运行结果：

CGLIB动态代理运行结果.png

JDK动态代理与CGLIB动态代理的区别：

1.JDK针对接口的类实现代理，CGLIB针对类实现代理
2.JDK代理的方式是生产接口实现类的兄弟类用来完成代理,
CGLIB代理的方式通过继承被代理类的方式完成的代理。