一、代理
代理就是为某个对象提供一个代理对象，通过这个代理对象来控制对这个对象的访问。
二、静态代理
静态代理也就是说在程序运行前已经存在了编译好的代理类，
其实现主要分为四步：
1、定义业务接口
2、被代理类（委托类）实现业务接口
3、定义代理类并实现业务接口
4、客户端调用
代码：
1、定义业务接口
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:39
*/
public interface TestService {
void add(String name);
}
2、被代理类实现业务接口
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:40
*/
public class TestServiceImpl implements TestService {
@Override
public void add(String name) {
System.out.println("已经向"+ name+"发送添加请求");
}
}
3、代理类实现业务接口
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:42
*/
public class TestServiceProxy implements TestService {
private TestService test;
public TestServiceProxy(TestService test){
this.test = test;
}
@Override
public void add(String name) {
System.out.println("添加好友");
test.add(name);
System.out.println("添加请求已经发送，等待对方同意");
}
}
4、客户端调用
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:47
*/
public class Main {
public static void main(String[] args) {
TestService test = new TestServiceImpl();
TestServiceProxy proxy = new TestServiceProxy(test);
proxy.add("heqinz");
}
}
打印结果
添加好友
已经向heqinz发送添加请求
添加请求已经发送，等待对方同意
静态代理的优缺点：
优点：业务类只关注业务本身，保证了业务类的重用性。
缺点：1、代理对象一个接口对应一种类型的对象，代理的方法多了，那每种方法都要进行一次代理
2、接口增加一个方法，除了所有方法都要实现这个方法外，所有代理类也需要实现此方法，增加了代码维护的复杂度。
三、动态代理
动态代理就是在程序运行期间，需要动态的创建代理类以及实例来完成具体的功能。
动态代理的实现：
步骤:
1、创建被代理的接口和类
2、创建 InvocationHandler接口的实现类，在invoke方法中实现代理逻辑。
3、通过proxy的静态方法 newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h) 创建一个代理对象
4、使用代理对象
实现
1、接口类；
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:39
*/
public interface TestService {
void add(String name);
}
2、被代理实现类：
package com.heqinz;
/**
* @author admin
* @date 2020/10/19 13:40
*/
public class TestServiceImpl implements TestService {
@Override
public void add(String name) {
System.out.println("已经向"+ name+"发送添加请求");
}
}
3、创建InvocationHandler接口的实现类
package com.heqinz;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* @author admin
* @date 2020/10/19 14:17
*/
public class MyInvocationHandler implements InvocationHandler {
private Object test;
public MyInvocationHandler (Object test){
this.test = test;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("添加好友");
Object returnTest = method.invoke(test,args);
System.out.println("添加请求已经发送，等待对方同意");
return returnTest;
}
}
4、使用代理对象
关于传入的三个参数介绍：
1、代理类的类加载器
2、代理类需要的接口
3、invocation handler,用来处理方法的调用
package com.heqinz;
import com.sun.deploy.net.proxy.DynamicProxyManager;
import java.lang.reflect.Proxy;
/**
* @author admin
* @date 2020/10/19 14:20
*/
public class Main1 {
public static void main(String[] args) {
TestService test = new TestServiceImpl();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(test);
TestService proxyObject = (TestService) Proxy.newProxyInstance(DynamicProxyManager.class.getClassLoader(),test.getClass().getInterfaces(),myInvocationHandler);
proxyObject.add("heqinz");
}
}
结果与静态代理是一样的
