注解+反射+动态代理实现自定义IOC

已于 2022-08-29 19:55:26 修改
阅读量298 收藏
点赞数 1
分类专栏： 学习笔记 文章标签： java mybatis spring
于 2022-08-27 10:17:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32300737/article/details/126554808
版权

目的

仅限于练习注解和反射以及代理的使用。

实现

容器加载以及测试类

/**
 * @author : hongbo.liu
 * @date : 15:06 2022/7/27
 * 自定义IOC容器
 * 1，扫描指定包中的全限定类名（不支持扫描jar包中的class）
 * 2，获取需要进行增强的自定义注解名称
 * 3，创建bean并缓存，此处需要校验是否需要创建代理对象（扫描类方法的注解，如果包含aop的注解则需要创建代理对象）
 * 4，依赖注入，如果class对象的属性有注入的注解，则需要为其赋值，从bean map中获取，如果没有，则递归执行步骤 3
 */

public class CustomizeIocContainer {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //1,扫描指定的包，获取类全限定类名
        List<Class<?>> classes = ClassPathUtil.getClasses("aop");
        //2,获取指定注解的类中代理的方法信息
        ProxyBeanHandler.getProxyMethodByAnnotation(classes);
        //3，如果不需要生成代理，则直接通过反射将类对象缓存，否则，生成代理对象缓存
        ProxyBeanHandler.createProxyBean(classes);

        //从bean map中获取实例测试
        ProxyTest proxyTest = (ProxyTest) ProxyBeanHandler.beanMap.get("proxyTest");
        proxyTest.proxyTest();
    }

}

获取指定包下的全限定类名

/**
 * @author : hongbo.liu
 * @date : 16:22 2022/7/27
 * <p>
 * 获取指定包下类的权限的类名
 */
public class ClassPathUtil<T> {

    public static volatile List<String> classPaths = new ArrayList<String>();
    //先把包名转换为路径,首先得到项目的classpath
    public static volatile String classpath = Main.class.getResource("/").getPath();
    //包名basePageName转换为路径名
    public static final String basePageName = "aop".replace(".", File.separator);

    public static final String finalBasePageName = basePageName;

    public static synchronized List<Class<?>> getClasses(String basePageName) {

        //classpath和basePageName合并
        String searchPath = (classpath + basePageName).replace("test-classes", "classes");

        //获取指定包下全限定类名
        doPath(new File(searchPath));

        //筛选出符合条件的class对象
        return filterClass().apply(classPaths);

    }

    /**
     * 递归获取class文件 将类的绝对路径写入到classPaths中
     * @param file
     */
    private static synchronized void doPath(File file) {
        if (file.isDirectory()) {
            //递归文件夹
            File[] files = file.listFiles();
            Arrays.stream(files).forEach(item ->{doPath(item);});
        } else {
            //获取class文件
            if (file.getName().endsWith(".class")) {
                classPaths.add(file.getPath());
            }
        }
    }

    /**
     * 过滤符合要求的class对象
     * @return
     */
    public static synchronized Function<List<String>, List<Class<?>>> filterClass() {
        List<Class<?>> classes = new ArrayList();
        return new Function<List<String>, List<Class<?>>>() {
            @SneakyThrows
            @Override
            public List<Class<?>> apply(List<String> strings) {
                classPaths.stream().forEach(new Consumer<String>() {
                    @SneakyThrows
                    @Override
                    public void accept(String s) {
                        s = s.replace(classpath.replace("/", "\\").replaceFirst("\\\\", ""), "").replace("\\", ".").replace(".class", "");
                        int beg = s.indexOf(finalBasePageName + ".");
                        Class<?> aClass = Class.forName(s.substring(beg, s.length()));
                        // 过滤出带@MyService和@MyAspect注解的类
                        if (aClass.getAnnotation(MyService.class) != null || aClass.getAnnotation(MyAspect.class) != null) {
                            classes.add(aClass);
                        }
                    }
                });
                return classes;
            }
        };
    }
}

生成代理对象完成依赖注入并存入缓存

/**
 * @author : hongbo.liu
 * @date : 16:27 2022/7/27
 * 类注解过滤
 */
public class ProxyBeanHandler {

    public static Map<String, Object> beanMap = new HashMap<>();

    public static Map<String, Map<String, String>> proxyMethod = new HashMap<>();

    public static Map<String, Object> createProxyBean(List<Class<?>> classes) {
        classes.stream().forEach(item -> {
            if (item.getAnnotation(MyService.class) != null) {//过滤出带@MyService注解的类
                if (item.getInterfaces().length > 0) {
                    try {
                        Object obj = item.newInstance();
                        String className = obj.getClass().getInterfaces()[0].getSimpleName();
                        String beanName = className.substring(0, 1).toLowerCase() + className.substring(1, className.length());
                        //如果bean已经存在则不需要创建，跳出本次循环
                        if (beanMap.containsKey(beanName)) return;
                        //依赖注入
                        dependencyInjection(obj);
                        //增强切入点,将代理对象缓存到map
                        enhancementPoint(obj, beanName);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        return beanMap;
    }

    /**
     * 增强代理方法，并将代理对象存入map中
     *
     * @param obj
     * @param beanName
     */
    private static void enhancementPoint(Object obj, String beanName)  {
        //获取包含Aop的注解
        Method[] declaredMethods = obj.getClass().getDeclaredMethods();
        if (proxyMethod != null && proxyMethod.size() > 0) {
            Arrays.stream(declaredMethods).forEach(
                    item -> {
                        Annotation[] annotations = item.getAnnotations();
                        if (annotations.length > 0) {
                            Arrays.stream(annotations).forEach(one -> {
                                if (proxyMethod.containsKey(one.annotationType().getSimpleName())) {
                                    //子类实现接口不为空，则生成基于JDK代理对象
                                    Class<?>[] interfaces = obj.getClass().getInterfaces();
                                    if (interfaces != null && interfaces.length > 0) {
                                        Object proxyObject = null;
                                        try {
                                            proxyObject = new ProxyFactory().createProxy(obj, Class.forName(proxyMethod.get(one.annotationType().getSimpleName()).get(AopEnum.ASPECT_ANNOTATION_KEY.getKey())).newInstance());
                                        } catch (InstantiationException e) {
                                            e.printStackTrace();
                                        } catch (IllegalAccessException e) {
                                            e.printStackTrace();
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                        beanMap.put(beanName, proxyObject);
                                    }
                                }
                            });
                        }
                    }
            );
        }
        //如果bean方法没有增强注解，则生成普通代理对象（此处可以改为普通对象obj）
        if (beanMap.get(beanName) == null) {
            //生成代理对象
            Object proxyObject = new ProxyFactory().createProxy(obj, new Object());
            beanMap.put(beanName, proxyObject);
        }
    }

    /**
     * 递归给属性注入依赖
     * @param obj
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws ClassNotFoundException
     */
    private static void dependencyInjection(Object obj) {
        //给obj带@MyAutowired注解的属性注入依赖（代理对象）
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        Arrays.stream(declaredFields).forEach(field -> {
            Annotation[] declaredAnnotations = field.getDeclaredAnnotations();
            Arrays.stream(declaredAnnotations).forEach(annotation -> {
                //有@MyAutowired注解
                if (annotation.annotationType().getTypeName().equals(MyAutowired.class.getTypeName())) {
                    //将代理map中的代理对象设置给当前属性
                    Object proxyBean = ProxyBeanHandler.beanMap.get(field.getName());
                    //如果从bean集合中获取的对象为空，则创建该对象，并放入代理map缓存中
                    if (proxyBean == null) {
                        Set<Class<?>> sonClassSet = getSonClassInstances(field.getType());
                        //默认第一个接口的子类class对象
                        List<Class<?>> sunClass = new ArrayList<>();
                        if (!CollectionUtils.isEmpty(sonClassSet)) sunClass.add(sonClassSet.iterator().next());
                        //递归调用createProxyBean完成依赖注入
                        ProxyBeanHandler.createProxyBean(sunClass);
                        //再次从beanMap获取，如果获取不到则报错提示
                        proxyBean = ProxyBeanHandler.beanMap.get(field.getName());
                        if (proxyBean == null)
                            throw new RuntimeException("create " + obj.getClass().getSimpleName() + "proxy bean error ," + field.getName() + "bean is not find");
                    }
                    try {
                        field.set(obj, proxyBean);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
    }

    /**
     * 获取需要增强的方法上面的注解
     *
     * @param classes
     * @return
     * @throws ClassNotFoundException
     */
    public static void getProxyMethodByAnnotation(List<Class<?>> classes) {
        classes.forEach(item -> {
            try {
                //获取指定注解的class对象
                if (item.getAnnotation(MyAspect.class) != null) {
                    Method[] declaredMethods = item.getDeclaredMethods();
                    Arrays.stream(declaredMethods).forEach(method -> {
                        if (method.getAnnotation(MyPointcut.class) != null) {
                            Map map = new HashMap();
                            map.put(AopEnum.ASPECT_ANNOTATION_KEY.getKey(), item.getTypeName());
                            proxyMethod.put(method.getAnnotation(MyPointcut.class).value(), map);
                        }
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 获取子类class对象
     *
     * @param supClass
     * @return
     */
    private static Set<Class<?>> getSonClassInstances(Class supClass) {
        String aPackage = ClassUtil.getPackage(supClass);
        Set<Class<?>> classes = ClassUtil.scanPackage(aPackage);
        Set<Class<?>> collect = classes.stream().filter(sonClass -> {
            boolean allAssignableFrom = ClassUtil.isAllAssignableFrom(new Class[]{supClass},
                    new Class[]{sonClass});
            //将本身排除
            return allAssignableFrom && sonClass != supClass;
        }).collect(Collectors.toSet());
        return collect;
    }
}

代理工厂

/**
 * @author : hongbo.liu
 * @date : 17:14 2022/7/27
 * 代理工厂,对指定注解的方法进行代理
 * target 被代理的对象
 * point用于增强方法的对象
 */
public class ProxyFactory implements InvocationHandler {

    Object target;//被代理的对象

    Object point;//代理方法切入点

    public Object createProxy(Object target, Object point) {
        this.target = target;
        this.point = point;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return handleProxyMethod(method, args);
    }

    /**
     * 处理代理方法
     * @param method
     * @param args
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws InvocationTargetException
     */
    public Object handleProxyMethod(Method method, Object[] args) throws IllegalAccessException, InstantiationException, InvocationTargetException {
        //如果代理对象执行的方法和目标对象的方法名称一样，参数列表一样，并且目标对象的方法上有@MyAop注解，则需要对该方法进行增强
        Method[] targetDeclaredMethods = target.getClass().getDeclaredMethods();
        for (Method targetMethod : targetDeclaredMethods) {
            if (containAnnotation(targetMethod.getDeclaredAnnotations()) && method.getName().equals(targetMethod.getName())) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                Class<?>[] targetParameterTypes = targetMethod.getParameterTypes();
                boolean isPoint = parameterTypes.length == targetParameterTypes.length && targetParameterTypes.length == 0;
                if (parameterTypes.length == targetParameterTypes.length && targetParameterTypes.length != 0) {//参数个数一样
                    for (int i = 0; i < parameterTypes.length; i++) {//校验参数类型是否一致
                        if (!parameterTypes[i].getTypeName().equals(targetParameterTypes[i].getTypeName())) {//如果有一个参数类型不一致，则为重载的方法，不能做增强
                            isPoint = false;
                        }
                    }
                }
                //如果方法名称一样，参数列表也一样，则做增强
                if (isPoint) {
                    //增强类的方法列表
                    Method[] declaredMethods = point.getClass().getDeclaredMethods();
                    //实例化增强类对象
                    Object obj = point.getClass().newInstance();
                    for (Method md : declaredMethods) {
                        //找到增强类的具体增强方法，将被增强的方法、对象、参数传递进去
                        if (md.getAnnotation(MyPointcut.class) != null) {
                            return md.invoke(obj, new Object[]{method, target, args});
                        }
                    }
                }
            }
        }
        //不含@MyAop注解的方法则不走代理
        return method.invoke(target, args);
    }


    /**
     * 判断方法的注解是否包含@MyAop
     *
     * @param declaredAnnotations
     * @return
     */
    private boolean containAnnotation(Annotation[] declaredAnnotations) {
        boolean isContain = false;
        for (Annotation declaredAnnotation : declaredAnnotations) {
            if (declaredAnnotation.annotationType().getSimpleName().equals(MyAop.class.getSimpleName())) {
                isContain = true;
                break;
            }
        }
        return isContain;
    }

}

注解类

/**
 * @author : hongbo.liu
 * @date : 17:03 2022/7/27
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAop {
}

/**
 * @author : hongbo.liu
 * @date : 16:45 2022/7/27
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
    String value() default "";
}

/**
 * @author : hongbo.liu
 * @date : 14:56 2022/7/28
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAutowired {
    String value() default "";
}

/**
 * @author : hongbo.liu
 * @date : 16:49 2022/7/27
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Service
public @interface MyPointcut {
    String value() default "";
}

/**
 * @author : hongbo.liu
 * @date : 16:35 2022/7/27
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyService {
    /**
     * bean名称
     * @return
     */
    String value() default "";

}

枚举

/**
 * @author : hongbo.liu
 * @date : 10:00 2022/8/8
 */

public enum AopEnum {
    /**
     * 自定义增强注解key
     */
    ASPECT_ANNOTATION_KEY("class");

    private String key;

    AopEnum(String key) {
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }
}

切面

/**
 * @author : hongbo.liu
 * @date : 17:03 2022/7/27
 */
@MyAspect
public class ServiceAspect {
    @MyPointcut("MyAop")
    public Object serviceAspect(Method method, Object target, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("方法执行前..............");
        method.invoke(target, args);
        System.out.println("方法执行后..............");
        return null;
    }
}

测试接口

/**
 * @author : hongbo.liu
 * @date : 17:14 2022/7/28
 */
public interface ProxyTest {
    void proxyTest();
}

测试接口实现类

/**
 * @author : hongbo.liu
 * @date : 17:09 2022/7/28
 */
@MyService
public class ProxyTestImpl implements ProxyTest {

    @MyAutowired
    public TestService testService;

    public void proxyTest(){
        testService.get();
    }
}
c# 简单的IOC实现框架,包含通过配置，利用c#反射机制来动态注入
08-26
c# 简单的IOC实现框架,包含通过配置，利用c#反射机制来动态注入
C# WPF通过反射及Ioc容器综合实例
dotNET跨平台
01-21 597
概述 这节主要通过发射+Caliburn.Micro自带的ioc容器实现加载并显示其它项目中的界面.实现效果如下：具体实现 -. ①首先在引导程序页面通过发射加载类库，并将视图注入ioc容器，这里为了实现解耦合注入了ICommonBasePage接口类型：private void ExternalLoad() { //container = ne...
ioc框架,通过动态代理实现.
05-28
ioc框架,通过动态代理实现.可以参考学习下
利用Java的反射与代理实现IOC模式
cool_rain_man的专栏
05-05 1083
原址：http://tech.it168.com/j/2007-10-12/200710121015609.shtml     在Java中，其反射和动态代理机制极其强大，我们可以通过其反 射机制在运行时获取信息。而代理是一种基本的设计模式，它是一种为了提供额外的或不同的操作而插入到真 实对象中的某个对象。而Java的动态代理在代理上更进一步，既能动态的创建代理对象，又能动
注解、反射、动态代理
ChiZng的博客
09-07 148
注解、反射、动态代理 涉及到的知识点注解、反射、动态代理，AOP、Lombok，代理模式、`builder模式``````````` Q：工作中用到过注解吗，简单介绍一下。 A：在日常开发中经常使用注解，包括Java提供的@Overried、@Deprecated，一些框架提供的如SpringMVC的@Controller、@Service、@Compontent、@Configuration、@Bean等Lombok的@Data、@Builder等，还有自己结合Spring的AOP来实现日志记录和权限校验
实现接口代理增强，并动态注入到IOC容器中（类似于Feign或Mybatis的Mapper）
qq_40518157的博客
07-01 1019
参考链接 创建动态代理对象bean，并动态注入到spring容器中 Mybatis是如何向Spring注册Mapper的
注解反射&动态代理的封装
半身风雪
04-12 308
注解反射&动态代理的封装1、自定义注解&动态代理的简单实现2、代理优化封装 1、自定义注解&动态代理的简单实现 需求场景： 通过自定义注解方式，实现按钮的点击效果，和长按效果 我们先写两个按钮 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://sc
反射+自定义注解
zhangshuai66的博客
08-17 783
反射和注解学习
IoC容器的设计（利用反射、注解和工厂模式实现）
最新发布
06-24
实验要求 1. 利用注解、反射和工厂模式设计一个简单的IoC容器 2. 该IoC容器包含3个...然后我们需要自己实现一个IoC容器类，处理自定义的注解的基本逻辑； 接下来在test类中实例化IoC容器，并从中取得bean，调用其方法
Spring AOP+Annotation切面式注解实现自定义系统日志
一位葛先生
03-18 918
写在前面：此实现感谢我大杰哥 后期我大杰哥会有针对此日志实现的优化，包括注入LogUserService 的懒加载问题 切面编程和自定义注解的技术博客自行研究 【SpringBoot笔记8】Spring AOP 面向切面编程（应用篇） 自定义注解详细介绍 目标： 实现用户操作、操作方法、执行结果的一站式记录 思路： 1. 使用切面编程的方式处理用户操作中系统调用方法的环绕通知式记录，包括调用前获得...
Spring IOC 原理 ，Java 反射实例，自定义注解
04-23
总的来说，Spring的IOC结合Java反射和自定义注解，构建了一种灵活且强大的组件管理和依赖注入机制。通过深入理解这些概念，开发者可以更好地利用Spring框架，实现松耦合、高内聚的软件设计。在实际项目中，可以使用`...
注解&反射（三）【实战--Android View IOC框架的两种实现方案】
itbird的专栏
04-18 1975
控制反转(Inversion of Control，英文缩写为IoC)，把创建对象的权利交给框架,是框架的重要特征，并非面向对象编程的专用术语。它包括依赖注入(Dependency Injection，简称DI)和依赖查找(Dependency Lookup)。 说完概念定义，IOC好像就是把new 对象的权利交由框架去实现，这样Java代码中就不必要那么多的new操作了。仅此而已吗？NO、NO、NO，Android中我们经常会使用BindView框架，为什么使用它呢？因为它让我们省去了很多findVi.
iOS 代理，代理是实现反向传值步骤
CloverZhu的博客
10-15 617
在帮忙的地方  .h 文件中： 1，声明代理 方法 @protocol DownLoadOperationDelegate - (void)didFinishDownLoadWithImage:(UIImage *)iamge; @end 2， #pragma mark -----------代理传值2，声明一个属性 作为代理
spring注解方式实现ioc控制反转
yjz_sdau的博客
04-12 575
该文使用例子代码，源于此文书写的ioc配置文件方式做的修改。https://blog.csdn.net/yjz_sdau/article/details/79904755注解方式跟配置文件方式原理一样，但是注解更方便也便于管理，因为注解方式，我们把很多管理的书写交给了spring给我们做，所以对于我们开发来说，带来了更大的便利。&lt;?xml version="1.0" encoding="UT...
浅谈IOC、AOP、反射实现AOP代理
lu__lala的博客
03-18 644
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 1.IOC控制反转 控制反转(inversion of control), 是一种设计思想,DI(dependenc
一张图说明反向代理区别
yangrui0070的博客
01-05 476
一直很奇怪反向代理这个定义，总是觉得正向代理和反向代理的区别不是很大。于是今天和老大讨论了一下。老大告诉我，所谓代理，那就是将属于原封不动的传递，才叫做代理。而反向代理，即代理服务器将从客户端传递来的请求，经过处理，再传递到服务器去。当在从服务器返回数据的时候，却是不经处理返回到客户端的。所以这种情况才叫做反向代理。如图所示
动态代理与反射机制
qq_39694454的博客
05-10 491
一、关于反射 什么是反射： 反射机制是Java提供的一种基础功能，让程序能在运行时自省(introspect)的能力。通过反射我们能直接操作某个类或对象，甚至可以在运行时修改类定义。 反射的作用： 1、在运行时判断任意对象所属的类 2、在运行时任意构造一个类的对象 3、在运行时判断任意类所具有的成员变量和方法 4、在运行时调用任意对象的方法 应用场景： 反射技术常用在各类通用框架开发中。因为为了保证框架的通用性，需要根据配置文件加载不同的对象或类，并调用不同的方法，这个时候就会用到反射——运行时动态加载需
C#实现IOC
zhanglianzhu_91的博客
07-22 2272
C#实现IOC容器
C#通过反射动态加载dll，读取module、类、方法、特性，并通过反射+简单工厂+配置文件 实现ioc
踏雪寻梅
04-06 5954
调用类：class Program { static void Main(string[] args) { SafeInvoke(() =&gt; {//通过委托实现通用的异常处理 #region 通过反射创建对象 { //1 动态加载 默认加载当前路径的dll文...
深入解析自定义IOC依赖注入源码实现
5. **自定义IOC容器的优化和扩展**：在理解了基本实现原理后，开发者可能会考虑对容器进行性能优化，如使用缓存机制减少反射的性能损耗，或者增加新的功能以满足特定需求，比如事务管理、事件发布等。 6. **自定义...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值