#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("李峰");
}
}
运行结果：
#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();
}
运行结果：
####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;
}
}
运行结果：
##JDK动态代理与CGLIB动态代理的区别：
1.JDK针对接口的类实现代理，CGLIB针对类实现代理
2.JDK代理的方式是生产接口实现类的兄弟类用来完成代理,
CGLIB代理的方式通过继承被代理类的方式完成的代理。