JAVA反射

最新推荐文章于 2024-11-01 09:00:00 发布

原创最新推荐文章于 2024-11-01 09:00:00 发布 · 167 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

13 篇文章

订阅专栏

Class类对象的三种实例化模式

Object类支持根据实例化对象获取Class对象
（需实例化相关对象；需导包）
JVM直接支持采用 “ 类.class ” 的形式实例化
（不用实例化相关对象；需导包）
Class类支持
（不用实例化相关对象；不用导包）

反射实例化对象

Class.newInstance()方法相当于new ，但实例化时只能调用对应无参构造函数，不能准确进行实例，在JDK1.9后被替代！（后通过构造方法进行实例化）

反射与工厂设计模式

package com.test3;
//传统工厂模式，弊端：当接口子类扩充时，工厂类需再加判断
public class ClassDemo {
    public static void main(String[] args) {
        IMessage iMessage = Factory.getInstance("NetMessage");
        iMessage.send();
    }
}

interface IMessage {
    public void send();//消息发送
}

class NetMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[网络消息发送www.cxf.com]");
    }
}

class Factory {
    private Factory() {}

    public static IMessage getInstance(String className) {
        if ("NetMessage".equals(className)) {
            return new NetMessage();
        }
        return null;
    }
}

package com.test3;
//利用反射修改后解决上述问题
public class ClassDemo {
    public static void main(String[] args) {
        IMessage iMessage = Factory.getInstance("com.test3.NetMessage");
        iMessage.send();
        IMessage iMessage1 = Factory.getInstance("com.test3.CloudMessage");
        iMessage1.send();
    }
}

interface IMessage {
    public void send();//消息发送
}

class NetMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[网络消息发送www.cxf.com]");
    }
}

class CloudMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[云消息发送www.cxf.com]");
    }
}

class Factory {
    private Factory() {}

    public static IMessage getInstance(String className) {
        IMessage instance = null;
        try {
            instance = (IMessage) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
}

当项目中接口数量大时，在工厂中给对应接口子类定义实例化方法，又回到了刚才的问题，如下

package com.test3;

public class ClassDemo {
    public static void main(String[] args) {
        IMessage iMessage = Factory.getInstance("com.test3.NetMessage");
        iMessage.send();
        IService iService = Factory.getIServiceInstance("com.test3.HouseService");
        iService.service();
    }
}
//消息接口
interface IMessage {
    public void send();//消息发送
}
//消息接口子类1
class NetMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[网络消息发送www.cxf.com]");
    }
}
//消息接口子类2
class CloudMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[云消息发送www.cxf.com]");
    }
}

//服务接口
interface IService{
    public void service();//提供服务
}
//服务接口子类1
class HouseService implements IService{
    @Override
    public void service() {
        System.out.println("[提供住房服务]");
    }
}

class Factory {
    private Factory() {}
    //消息实例方法
    public static IMessage getInstance(String className) {
        IMessage instance = null;
        try {
            instance = (IMessage) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
    //服务实例方法
    public static IService getIServiceInstance(String className) {
        IService instance = null;
        try {
            instance = (IService) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
}

解决方法如下：（使用泛型）

package com.test3;

public class ClassDemo {
    public static void main(String[] args) {
        IMessage iMessage = Factory.getInstance("com.test3.NetMessage",IMessage.class);
        iMessage.send();
        IService iService = Factory.getInstance("com.test3.HouseService",IService.class);
        iService.service();
    }
}
//消息接口
interface IMessage {
    public void send();//消息发送
}
//消息接口子类1
class NetMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[网络消息发送www.cxf.com]");
    }
}
//消息接口子类2
class CloudMessage implements IMessage {
    @Override
    public void send() {
        System.out.println("[云消息发送www.cxf.com]");
    }
}

//服务接口
interface IService{
    public void service();//提供服务
}
//服务接口子类1
class HouseService implements IService{
    @Override
    public void service() {
        System.out.println("[提供住房服务]");
    }
}

class Factory {
    private Factory() {}

    /**
     * 获取接口实例化对象
     * @param className 接口的子类
     * @param clazz 描述接口类型
     * @param <T>
     * @return 如果子类存在则返回指定接口实例化对象
     */
    public static <T> T getInstance(String className,Class<T> clazz) {
        T instance = null;
        try {
            instance = (T) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
}

此时的工厂设计模式不限定于指定的接口，而是可以为项目中所有的接口提供实例化服务!

反射与代理设计模式

代理设计模式是程序开发中使用最多的设计模式，其核心是有==真实业务实现类和代理业务实现类，并且代理业务实现类要比真实业务实现类完成更多的处理操作

所有的代理设计模式，如果按照设计要求，都必须基于接口的设计！！！

以下为静态代理设计模式，弊端在于一个代理类只为一个接口服务，当项目中接口数量多时，需编写大量功能相同的代理，应采用动态代理设计模式

package com.test4;

public class javaAPIDemo {
    public static void main(String[] args) {
        IMessage iMessage = new MessageProxy(new MessageReal());
        iMessage.send();
        //result：
        //[消息代理]进行消息通道的连接
		//[发送消息]cxf...
		//[消息代理]进行消息通道的关闭
    }
}

interface IMessage{
    public void send();
}

class MessageReal implements IMessage{ //真实业务实现类
    @Override
    public void send() {
        System.out.println("[发送消息]cxf...");
    }
}

class MessageProxy implements IMessage{ //代理业务实现类
    private IMessage message; //代理对象，一定是业务接口实例
    public MessageProxy(IMessage message){
        this.message = message;
    }
    @Override
    public void send() {
        if (connect()){
            this.message.send();
            close();
        }
    }
    public boolean connect(){
        System.out.println("[消息代理]进行消息通道的连接");
        return true;
    }
    public void close(){
        System.out.println("[消息代理]进行消息通道的关闭");
    }
}

动态代理机制需考虑的问题：
1. 不管是动态代理还是静态代理，都要接受真实业务实现子类对象
2. 由于动态代理不再与某一接口绑定，所以应该动态的获取类的接口信息

代码实现：

package com.test4;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class javaAPIDemo {
    public static void main(String[] args) {
        IMessage iMessage = (IMessage) new CXFProxy().bind(new MessageReal());
        iMessage.send();
        //result：
        //*************[执行方法]  public abstract void com.test4.IMessage.send()  *****************
		//[消息代理]进行消息通道的连接
		//[发送消息]cxf...
		//[消息代理]进行消息通道的关闭
    }
}

class CXFProxy implements InvocationHandler{
    private Object target; //保存真实业务对象
    /**
     * 进行真实业务对象与代理业务对象之间的绑定处理
     * @param target 真实业务对象
     * @return Proxy生成的代理业务对象
     */
    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 pro, Method method, Object[] args) throws Throwable {
        System.out.println("*************[执行方法]  " + method + "  *****************");
        Object returnData = null;
        if (connect()){
            returnData = method.invoke(this.target,args);
            close();
        }
        return returnData;
    }
}

interface IMessage{
    public void send();
}

class MessageReal implements IMessage{ //真实业务实现类
    @Override
    public void send() {
        System.out.println("[发送消息]cxf...");
    }
}