[Java知识库]动态代理、工厂模式、注解相结合实现对象创建

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactoryAnnotationCombine {
    public static void main(String[] args) {
        new MessageService().send();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@interface UseMessage{
    Class<?> clazz();
}

/**
 * 通过更改注解传入的类，
 * 可以去低耦合的去传入类型。
 * 从而实现去创建对象
 *
 */
//@UseMessage(clazz = MessageImpl.class)
@UseMessage(clazz = QQMessageImpl.class)
class MessageService{
    private IMessage iMessage;
    public MessageService(){
        /*
            通过注解去获取具体的类
            然后传递给工厂去实例化
            工厂可以实例化
         */
        UseMessage useMessage = MessageService.class.getAnnotation(UseMessage.class);
        try {
            Class clazz = useMessage.clazz();
            this.iMessage = (IMessage)MessageFactory.getInstance(clazz);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void send(){
        this.iMessage.send();
    }
}


class MessageFactory{
    private MessageFactory(){}
    public static <T>T  getInstance(Class<T> clazz){ // 传进来的就是需要直接创建对象的类
//        try {
//            return (T) clazz.getClass().getConstructor().newInstance();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;

        try {
            return (T)new MessageProxy().bind(clazz.getDeclaredConstructor().newInstance());
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }
}


class MessageProxy implements InvocationHandler{
    private Object object;

    public Object bind(Object object){
        this.object = object;
        return Proxy.newProxyInstance(this.object.getClass().getClassLoader(), this.object.getClass().getInterfaces(), this);
    }

    public boolean connect(){
        return true;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object retData = null;
        try {
            if(connect()){
                System.out.println("链接成功");
                retData = method.invoke(this.object, args);
            }
            // 当前委托对象调用方法
            return retData;
        } catch (Exception e) {
            throw new RuntimeException("连接失败");
        }
//        return null;
    }
}


class MessageImpl implements IMessage{
    @Override
    public void send() {
        System.out.println("发送");
    }
}

class QQMessageImpl implements IMessage{
    @Override
    public void send() {
        System.out.println("qq发送");
    }
}
interface IMessage{
    void send();
}