Java反射（反射与代理设计模式、反射与Annotation、自定义Annotation、反射整合工厂设计模式和代理设计模式）

package Example1709;
//业务接口实现发送消息
interface Message{
    public void  send();
}
//业务接口真实实现
class MessageReal implements Message{
    @Override
    public void send() {
        System.out.println("传输信息Message");
    }
}
//代理类
class Proxy{
//    通过实例化子类进行间接实现功能
    private MessageReal real = new MessageReal();
    public void getMessage() {
        real.send();
    }
}
public class javaDemo {
    public static void main(String[] args) {
        Proxy p = new Proxy();
        p.getMessage();
    }
}

package ExampleProxyeflect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//业务接口发送信息
interface Message{
    public void send();
}
//多种业务实现类
class LetterMessage implements Message{
    @Override
    public void send() {
        System.out.println("使用邮件进行传输");
    }
}
class PhoneMessage implements  Message{
    @Override
    public void send() {
        System.out.println("使用手机进行信息传输");
    }
}
class ComputerMessage implements  Message{
    @Override
    public void send() {
        System.out.println("通过电脑进行信息传输");
    }
}
//信息发送代理类
class MessageProxy implements InvocationHandler {
    private  Object target;
    public Object bind(Object target){
        this.target = target;
//        创建动态代理类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
//    方法实现的覆写
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnData = null;
        if (this.connect()){
             returnData = method.invoke(this.target,args);
             this.close();
        }
        return returnData;
    }
//    设置连接和断开函数
    public Boolean connect(){
        System.out.println("连接成功");
        return true;
    }
    public void close(){
        System.out.println("关闭连接");
    }
}
public class javaDemo {
    public static void main(String[] args) {
//        创建对象并调用方法
        Message msg = (Message) new MessageProxy().bind(new LetterMessage());
        msg.send();
    }
}

package Example1711;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
@Deprecated
@FunctionalInterface
interface Face{
     void face();
}
@SuppressWarnings("serial")
class Test implements Face, Serializable {
    @Override
    public void face() {
        System.out.println("No face");
    }
}
public class javaDemo {
    public static void main(String[] args) {
        Annotation tation[] = Face.class.getAnnotations();
        for (Annotation temp:tation) {
            System.out.println(temp);
        }
        Annotation taion2[] = Test.class.getAnnotations();
        for (Annotation temp:taion2) {
            System.out.println(temp);
        }
    }
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface FunctionalInterface{}

package Example1713;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface useMessage{
    public String title();
    public String value();
    public String Default()default "默认值，如果调用则返回这个默认";
}
class Message {
    @useMessage(title="Annotation的使用标题",value = "value的值")
    public void send(String str){
        System.out.println("输出信息"+str);
    }
}
public class javaDemo {
    public static void main(String[] args) throws Exception{
        String str;
//        调用方法
        Method mehod = Message.class.getMethod("send", String.class);
//        获取指定的Annotation
        useMessage msg = mehod.getAnnotation(useMessage.class);
        str = msg.Default();
//        实现方法调用
        mehod.invoke(Message.class.getDeclaredConstructor().newInstance(),str);
        str = msg.title();
        mehod.invoke(Message.class.getDeclaredConstructor().newInstance(),str);
        str = msg.value();
        mehod.invoke(Message.class.getDeclaredConstructor().newInstance(),str);
    }
}

package Example1714;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//业务接口
interface Message{
    public void send(String msg);
}
//业务实现类
class NetMessageImp implements Message{
    @Override
    public void send(String msg) {
        System.out.println("通过网络进行发送消息"+msg);
    }
}
class CloudMessageImp implements Message{
    @Override
    public void send(String msg) {
        System.out.println("通过云网络进行发送消息"+msg);
    }
}
//定义工厂类
class Factory{
//    私有化工厂类无法在外部实例化
    private Factory(){};
//    通过getInstance获取实例化的对象
    public static<T> T getInstance(Class<T> clazz){
        try {
            return (T) new MessageProxy().bind(clazz.getDeclaredConstructor().newInstance());
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}
//设置自定义Annotation
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface RealInstance {
    public Class<?> claszz();
    }
@RealInstance(claszz = NetMessageImp.class)
class MessageService{
    private Message msg;
    public MessageService(){
//        getAnnotation需要对应的class
        RealInstance cls = MessageService.class.getAnnotation(RealInstance.class);
        this.msg = (Message) Factory.getInstance(cls.claszz());
    }
    public void send(String msg){
        this.msg.send(msg);
    }
}
//设置代理类
class MessageProxy implements InvocationHandler{
    private Object target;
//    绑定并创建指定对象
    public  Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }
//    设置连接函数
    public boolean connect(){
        System.out.println("连接成功");
        return true;
    }
//    设置关闭函数
    public void close(){
        System.out.println("断开连接");
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            if (this.connect()){
                return method.invoke(this.target,args);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            this.close();
        }
        return null;
    }
}
public class javaDemo {
    public static void main(String[] args) {
        MessageService instance = new MessageService();
        instance.send("我去，这东西是真的复杂啊，需要好好仔细读完啊");
    }
}