代理proxy是一种设计模式，提供对目标对象的另外的访问模式。好处是可以扩展目标对象的功能。
在实际开发中，可以不修改别人已经写好的代码，通过代理的方式来扩展功能。
生活中的例子：我们们要邀请明星，并不是直接联系明星，而是通过经纪人。
关键点是代理对象对目标对象的扩展，并且会调用目标对象
静态代理需要定义接口或者父类，被代理的对象和代理对象要实现相中的接口或者继承相同的父类
public interface IUserDao{
public void work();
}
public class UserDao implements IUserDao{
public void work(String begin){
System.out.println("----"+begin+"点开始工作!----");
}
}
public class UserDaoProxy implements IUserDao{
//接收保存目标对象
private IUserDao userDao;
public UserDaoProxy(IUserDao userDao){
this.userDao=userDao;
}
public void work() {
System.out.println("---before--");
userDao.work();//执行目标对象的方法
System.out.println("---after---");
}
}
public class Test {
public static void main(String[] args) {
//目标对象
UserDao userDao= new UserDao();
//代理对象,把目标对象传给代理对象,建立代理关系
UserDaoProxy proxy = new UserDaoProxy(userDao);
proxy.work();//执行的是代理的方法
}
}
1、静态代理可以做到在不修改目标对象的功能前提下，对目标功能扩展
2、缺点是由于目标对象和代理对象实现共同的接口，所有会有很多的代理类，一旦接口增加方法，目标对象和代理对象都要维护，维护成本大
1、动态代理，代理对象不需要实现接口
2、代理对象的生成是利用JDK的API，在内存中动态的构建对象。需要指定创建代理或目标对象的接口的类型。
代理类所在的包：java.lang.reflect.Proxy，使用newProxyInstance方法，
该方法为静态方法，有三个参数分别为
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces,
InvocationHandler h)
ClassLoader loader：用哪个类加载器去加载代理对象
Class[] interfaces：动态代理类需要实现的接口
InvocationHandler h：动态代理方法在执行时，会调用h里面的invoke方法去执行。会把当前执行目标对象的方法作为参数传入
public class ProxyFactory{
//维护目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
//给目标对象生成代理对象
public Object getProxyInstance(){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("---before--");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("---after---");
return returnValue;
}
}
);
}
}
public class Test {
// 目标对象
IUserDao target = new UserDao();
// 给目标对象，创建代理对象
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
// 执行方法
proxy.work('9');
}
结果
---before--
----9点开始工作！----
---after---
- 动态代理的代理对象不需要实现接口，但是目标对象需要实现接口。
- JDK的动态代理需要目标对象实现接口，而Cglib能代理没有实现接口的类。它可以在运行期扩展Java类与实现Java接口，提供方法的interception（拦截）。
- Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
- Cglib动态构建子类,代理的类不能为final,目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法
public class UserDao {
public void work() {
System.out.println("----开始工作!----");
}
}
public class ProxyFactory implements MethodInterceptor{
//维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method,
Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("befor...");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("after...");
return returnValue;
}
}
public class Test{
@Test
public void test(){
//目标对象
UserDao target = new UserDao();
//代理对象
UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
proxy.work();
}
}
在Spring的AOP中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理
