手写代理通常指的是 动态代理，它是一种在程序运行时动态生成代理类的方式，而不是在程序运行前就存在的编译好的代理类。动态代理的核心在于使用Java的反射机制来生成代理类，从而实现对接口或类的代理。

动态代理的优点包括：

灵活性：

代理类是在运行时动态生成的，因此可以根据需要生成任意类型的代理类。

代码复用：

代理类可以复用已有的接口或类，无需重新编写大量代码。

解耦：

通过代理类，可以将客户端与目标对象解耦，便于维护和扩展。

动态代理的基本步骤如下：

定义接口：

首先需要定义一个接口，代理类将实现该接口。

创建InvocationHandler：

实现`java.lang.reflect.InvocationHandler`接口，该接口包含一个`invoke`方法，用于处理代理对象的方法调用。

生成代理类：

使用`java.lang.reflect.Proxy`类的`newProxyInstance`方法，根据指定的接口和`InvocationHandler`生成代理类。

```java

import java.lang.reflect.InvocationHandler；

import java.lang.reflect.Method；

import java.lang.reflect.Proxy；

interface TargetInterface {

void doSomething（）；

}

class TargetInterfaceImpl implements TargetInterface {

@Override

public void doSomething（） {

System.out.println（"Doing something..."）；

}

}

class MyInvocationHandler implements InvocationHandler {

private Object target；

public MyInvocationHandler（Object target） {

this.target = target；

}

@Override

public Object invoke（Object proxy, Method method, Object[] args） throws Throwable {

System.out.println（"Before method call..."）；

Object result = method.invoke（target, args）；

System.out.println（"After method call..."）；

return result；

}

}

public class DynamicProxyExample {

public static void main（String[] args） {

TargetInterface target = new TargetInterfaceImpl（）；

MyInvocationHandler handler = new MyInvocationHandler（target）；

TargetInterface proxy = （TargetInterface） Proxy.newProxyInstance（

target.getClass（）.getClassLoader（）,

new Class<？>[]{TargetInterface.class},

handler）；

proxy.doSomething（）；

}

}

```

在这个示例中，`TargetInterface`是目标接口，`TargetInterfaceImpl`是目标接口的实现类，`MyInvocationHandler`是自定义的`InvocationHandler`实现类，用于在方法调用前后添加额外的逻辑。最后，通过`Proxy.newProxyInstance`方法生成代理对象，并调用其`doSomething`方法。