新建一个接口interface
public interface CommonInterface {
void print(String string);
}
创建被代理对象类(目标类),需要实现interface
public class Target implements CommonInterface {
public void print(String string) {
System.out.println("this is CommonInterface and param is "+ string);
}
}
创建代理类,需要实现interface
public class ProxyClass implements CommonInterface {
// 静态代理的静态就体现在这里,把被代理的类对象硬编码。
private Target target = new Target();
public void print(String string) {
System.out.println("before target");
target.print(string);
System.out.println("after target");
}
}
测试类
public class Main {
public static void main(String[] args) {
ProxyClass proxyClass = new ProxyClass();
proxyClass.print("wangwang");
}
}
打印结果:
before target
this is CommonInterface and param is wangwang
after target
(2)动态代理
a、新建一个接口interface
b、创建被代理对象类(目标类),需要实现interface
c、创建代理类,需要实现InvocationHandler
d、测试类
新建一个接口interface
public interface CommonInterface {
int caculate(int a);
}
创建被代理对象类(目标类),需要实现interface
public class Target implements CommonInterface {
public int caculate(int a) {
return a * 2;
}
}
创建代理类,需要实现interface
public class DynamicProxy implements InvocationHandler {
private Object target = null;
public DynamicProxy(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
// 调用目标的方法
result = method.invoke(target,args);
// 方法增强,增加新的功能逻辑
if(result != null){
Integer res = (Integer)result;
res += 5;
result = res;
}
return result;
}
}
测试类
public class Main {
public static void main(String[] args) {
// 1、创建目标对象
Target target = new Target();
// 2、创建handler对象
DynamicProxy dynamicProxy = new DynamicProxy(target);
///3、创建代理对象
CommonInterface proxy = (CommonInterface)Proxy.newProxyInstance(target.getClass().getClassLoader()
,target.getClass().getInterfaces(),
dynamicProxy);
System.out.println(proxy.caculate(2));
}
}