java动态代理demo

/**
 * 增强注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface NeedLog {
}

/**
 * @description: 接口
 */
public interface UserService {
    void getUserInfo(String id);
}

/**
 * @description: 实现类
 */
@NeedLog
public class UserServiceImpl implements UserService {
    @Override
    public void getUserInfo(String id) {
        System.out.println("---sjn---查询用户信息：" + id);
    }
}

/**
 * @description: 增强接口
 */
public interface EnhancerHandler {
    default Object afterDo(Object t){
        return t;
    }
    default void preDo(){}
}

public class LogEnhancerHandler implements EnhancerHandler {
    @Override
    public Object afterDo(Object res) {
        System.out.println("---LogEnhancerHandler---afterDo---");
        return "---LogEnhancerHandler---afterDo---";
    }

    @Override
    public void preDo() {
        System.out.println("---LogEnhancerHandler---preDo---");
    }
}

public class CheckEnhancerHandler implements EnhancerHandler {
    @Override
    public Object afterDo(Object t) {
        System.out.println("---check---afterDo");
        return t;
    }

    @Override
    public void preDo() {
        System.out.println("---check---preDo");
    }
}

public class BeanFactory {
    /**
     * 单例池
     */
    Map<String, Object> singles = new HashMap();
    Map<String, EnhancerHandler> enhancers = new HashMap();

    public void register(String name, Object bean) {
        singles.put(name, bean);
    }

    public void addEnhancers(EnhancerHandler[] ens) {
        for (EnhancerHandler enhancer : ens) {
            String name = enhancer.getClass().getName();
            enhancers.put(name, enhancer);
        }
    }

    public Object getBean(String beanName) {
        return singles.get(beanName);
    }

    /**
     * 初始化对类进行增强，然后将代理的类放到单例池中
     */
    public void init() {
        singles.forEach((name, bean) -> {
            if (bean.getClass().isAnnotationPresent(NeedLog.class)) {
                ProxyFactory proxyFactory = new ProxyFactory();
                UserService uProxy = (UserService) proxyFactory.createProxy(bean, bean.getClass(), enhancers.values().stream().toArray(EnhancerHandler[]::new));
                singles.put(name, uProxy);
            }
        });
    }
}

public class ProxyFactory {
    public static Object createProxy(Object target, Class<?> clazz, EnhancerHandler[] enhancerHandlers) {
        return Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(), clazz.getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                preProcess(enhancerHandlers);
                Object res = method.invoke(target, args);
                afterProcess(res, enhancerHandlers);
                return res;
            }
        });
    }

    private static void afterProcess(Object res, EnhancerHandler[] enhancerHandlers) {
        for (EnhancerHandler enhancerHandler : enhancerHandlers) {
            enhancerHandler.afterDo(res);
        }
    }

    private static void preProcess(EnhancerHandler[] enhancerHandlers) {
        for (EnhancerHandler enhancerHandler : enhancerHandlers) {
            enhancerHandler.preDo();
        }
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        UserService im = new UserServiceImpl();
        BeanFactory beanFactory = new BeanFactory();
        //注册UserService
        beanFactory.register("UserService",im);

        LogEnhancerHandler logEnhancerHandler = new LogEnhancerHandler();
        CheckEnhancerHandler checkEnhancerHandler = new CheckEnhancerHandler();
        EnhancerHandler[] enhancerHandlers = {checkEnhancerHandler, logEnhancerHandler};

        //注册增强器
        beanFactory.addEnhancers(enhancerHandlers);

        beanFactory.init();
        UserService userService = (UserService) beanFactory.getBean("UserService");
        userService.getUserInfo("张三");
    }
}