注解方式自定义实现Spring Ioc容器 + 事务 + 动态代理

痛定思痛。 2022-12-26 11:24 138阅读 0赞

### 基于注解方式实现IOC容器 ###

*  前言
 *   *  步骤以及思路分析
     *  代码实现
     *   *  首先自定义注解
         *  项目结构
         *  配置信息
         *   *   *   *  定义初始化方法
                 *  文件扫描路径
                 *  bean实例化方法
                 *  bean依赖注入方法
                 *  事务处理注解方法
         *  包扫描
         *  bean实例化
         *  依赖注入
         *  扫描事务注解
         *  初始化方法步骤
         *  对外提供getBean(方法)
         *  测试
     *  代码仓库

# 前言 #

上一篇[点击查看][Link 1]使用xml来实现自定义IOC以及依赖注入关系维护,动态代理,以及事务操作;

这次使用注解来实现IOC以及依赖关系维护

## 步骤以及思路分析 ##

基于xml实现方式时,仅仅只需要在xml里面配置好bean的id以及bean的权限定命名,然后反射实例化对象,最后加入到ioc容器中  
依赖注入时候仅仅需要获取`property`标签以及父级标签,根据`property`名从ioc容器中获取到需要注入的bean示例即可;

如果是基于注解实现呢!

*  1 首先需要自定义注解
 *  2 如何获取自定义到的注解
 *  3 实例化打了注解的实例
 *  4 在指定bean成员变量上是否包含需要注入的注解,然后依赖注入
 *  5 生成代理对象,基于接口判断是否选择JDK动态代理或者CGLIB代理

## 代码实现 ##

### 首先自定义注解 ###

实例bean的注解 `@Repository` 和`@Service`

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Service { 
        String value() default "";
    }

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Repository { 
        String value() default "";
    }

自动装配的注解

@Target({  ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired { 
        String name() default "";
    }

事务注解 Transactional

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

然后 在类上标注注解,以及依赖注入  
![在这里插入图片描述][20201205150315551.png]  
事务注解以及DI 以及Bean自动装配  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70]

### 项目结构 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 1]

### 配置信息 ###

版本 JDK8 , tomcat 7 , IDEA 2019 03

所需依赖

<dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
          <scope>provided</scope>
        </dependency>
        
        
        <dependency>
          <groupId>cglib</groupId>
          <artifactId>cglib</artifactId>
          <version>2.1_2</version>
        </dependency>

tomcat插件

<plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
              <port>8080</port>
              <path>/</path>
            </configuration>
          </plugin>

这里我们使用一个`StartApplication`类来表示当前的顶级包下的启动类,相当于SpringBoot里的Main方法所在的类(目的仅仅是指定包,也可以在xml里面配置包名)

在Web.xml里面进行配置一下这个启动类

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" >
    <web-app>
        <display-name>tomcat启动时候启动IOC容器</display-name>
        <listener>
            
            
            <listener-class>com.udeam.edu.factory.impl.AnnotationBeanFactory</listener-class>
            
            
        </listener>
    </web-app>

定义`BeanFactory`接口类

/** * 底层BeanFactory工厂接口 * @author Pilgrim */
    public interface BeanFactory { 
    
        /** * 存储bean单例 */
        public final static Map<String, Object> IOC_MAP = new HashMap<>();
    
    
        /** * 对外提供获取bean接口 * * @param id * @return bean对象 */
        public Object getBean(String id);
    
    
        /** * 根据类型对外提供获取bean示例 * * @param classz * @return bean */
        public Object getBean(Class<?> classz);
    
        /** * 获取容器中所有的bean名字 * * @return */
        public Object getAllBeanName();
    }

抽象类`AbstractBeanFactory`扩展一些属性

public abstract class AbstractBeanFactory implements BeanFactory { 
    
        /** * 存储bean单例 */
        public final static Map<String, Object> IOC_MAP = new HashMap<>();
    
        /** * 容器执行一次 标识 */
        public static boolean isTag = false;
    
        public static final String CLASS_STR = ".class";
    
    }

然后编写bean工厂实现类`AnnotationBeanFactory`

###### 定义初始化方法 ######

initBeanFactory(String packageName);

初始化方法包含以下方法

##### 文件扫描路径 #####

##### bean实例化方法 #####

private void setBean();

##### bean依赖注入方法 #####

beanAutoWired()

##### 事务处理注解方法 #####

doScanTransactional()

/** * 注解方式 实现 Bean工厂 * * @author Pilgrim */
    public class AnnotationBeanFactory extends AbstractBeanFactory { 
    
        /** * 2 注解 + 扫描包 方式实现 ioc 容器 * tomcat启动的时候去初始化容器 */
        public AnnotationBeanFactory() { 
                if (isTag) { 
                return;
            }
            try { 
                String packageName = StartApplication.class.getPackage().getName();
                //扫描启动类的包名
                System.out.println("------------------- [容器]正在初始化 ------------ ");
                System.out.println(String.format("------------------- 扫描当前包是%s ------------ ", packageName));
                initBeanFactory(packageName);
                System.out.println("------------------- [容器]初始化完成 ------------ ");
            } catch (UnsupportedEncodingException e) { 
                e.printStackTrace();
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            } catch (InstantiationException e) { 
                e.printStackTrace();
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            isTag = true;
    	}
    
    
    }

### 包扫描 ###

递归扫描包下的文件  
com.xxx.xxx 包名需要转换成磁盘目录 c:/xxx/xx这样的形式

获取包名

String packageName = StartApplication.class.getPackage().getName();

转换包名以及扫描包得到所有的class文件名

if (Objects.isNull(packName) || packName.length() == 0) { 
                throw new RuntimeException("无效的包路径");
            }
            packName = packName.replace(".", File.separator);
            URL resource = AnnotationBeanFactory.class.getClassLoader().getResource(packName);
            String path = resource.getPath();
            //解析中文
            String filePath = URLDecoder.decode(path, "UTF-8");

递归处理

/** * 递归处理路径下文件夹是否包含文件夹,如不包含则获取当前类的权限定命名存入set中 * * @param packName * @param classNameSet * @param path */
        public static void parseFilePackName(String packName, Set<String> classNameSet, String path) { 
    
            File packNamePath = new File(path);
    
            if (!packNamePath.isDirectory() || !packNamePath.exists()) { 
                return;
            }
            //递归路径下所有文件和文件夹
            for (File file : packNamePath.listFiles()) { 
                boolean directory = file.isDirectory();
                String classNamePath = packName + File.separator + file.getName().replace(File.separator, ".");
                if (directory) { 
                    parseFilePackName(classNamePath, classNameSet, file.getPath());
                } else if (file.isFile() && file.getName().endsWith(CLASS_STR)) { 
                    //存入set
                    classNameSet.add(classNamePath.replace(File.separator, ".").replace(CLASS_STR, ""));
                }
            }
    
        }

### bean实例化 ###

得到所有的java文件名,然后去实例化bean

判断是否包含我们刚才自定义的注解

private void setBean() { 
            stringSet.forEach(x -> { 
                try { 
                    //排除指定包 servlet 类不能被实例化 这儿排除
                    if (!x.contains("servlet")) { 
                        Class<?> aClassz = Class.forName(x);
                        serviceAnnotation(aClassz);
                        repositoryAnnotation(aClassz);
                    }
                } catch (ClassNotFoundException e) { 
                    e.printStackTrace();
                } catch (IllegalAccessException e) { 
                    e.printStackTrace();
                } catch (InstantiationException e) { 
                    e.printStackTrace();
                }
            });
        }

判断是否含有`Service`和`Repository`注解

> 获取bean的名字 并且判断当前类是否有 Service 注解,如有则存入Ioc 如包含属性value不为空,则设置value属性为bean的key

public void serviceAnnotation(Class aClass1) throws InstantiationException, IllegalAccessException { 
            Service annotation = (Service) aClass1.getAnnotation(Service.class);
            if (Objects.nonNull(annotation)) { 
                setIocNameMap(annotation.value(), aClass1.getSimpleName(), aClass1);
            }
        }

Repository 同理

public void repositoryAnnotation(Class aClass) throws InstantiationException, IllegalAccessException { 
            Repository annotation = (Repository) aClass.getAnnotation(Repository.class);
            if (Objects.nonNull(annotation)) { 
                setIocNameMap(annotation.value(), aClass.getSimpleName(), aClass);
            }
        }

获取bean的name `setIocNameMap`方法然后实例化bean加入到容器  
这儿判断一下是否是单例bean 这儿的单例指的是是否已经有一个bean了

public void setIocNameMap(String value, String className, Class clasz) throws IllegalAccessException, InstantiationException { 
            String iocNameString = value;
            Object beanDefinition =  clasz.newInstance() ;
            if (value.length() > 0) { 
                if (IOC_MAP.containsKey(value)) { 
                    throw new RuntimeException("the named" + className + ", had one ... ");
                }
            } else { 
                //默认设置bean首字母小写的
                iocNameString = getIocNameString(className);
                if (IOC_MAP.containsKey(iocNameString)) { 
                    throw new RuntimeException("the named " + className + ", had one ... ");
                }
            }
    
            // 根据父接口类型注入
            Class<?>[] interfaces = clasz.getInterfaces();
            if (interfaces != null) { 
                for (Class<?> anInterface : interfaces) { 
                    IOC_MAP.put(anInterface.getSimpleName(), beanDefinition);
                }
            }
            IOC_MAP.put(iocNameString, beanDefinition);
        }

设置首字母小写

public static String getIocNameString(String className) { 
            return (String.valueOf(className.toCharArray()[0])).toLowerCase() + className.substring(1, className.length());
        }

### 依赖注入 ###

依赖注入方法,获取成员变量上有 Autowired 注解的字段,然后根据当前类类型去自动装配

public static void beanAutoWired() throws ClassNotFoundException { 
            //获取成员变量上有 Autowired 注解的字段,然后根据当前类类型去自动装配
            for (Map.Entry<String, Object> stringObjectEntry : IOC_MAP.entrySet()) { 
    
                Object beanDefinition = stringObjectEntry.getValue();
                Class<?> aClass = beanDefinition.getClass();
                Field[] declaredFields = aClass.getDeclaredFields();
    
                if (Objects.isNull(declaredFields) && declaredFields.length == 0) { 
                    continue;
                }
    
                for (Field field : declaredFields) { 
                    //字段含有 Autowired 注解的需要被自动装配对象
                    Autowired autowired = field.getAnnotation(Autowired.class);
    
                    if (Objects.nonNull(autowired)) { 
                        //根据当前key获取需要注入示例对象
                        //先根据名字注入,如果名字获取不到,再根据类型去注入
                        String beanName = autowired.name();
    
                        if (StringUtils.isEmpty(beanName)) { 
                            beanName = field.getType().getSimpleName();
                        }
    
                        //反射设置值
                        try { 
                            field.setAccessible(true);
                            //自动装配 线程不安全,Spring中默认单例
                            field.set(stringObjectEntry.getValue(), IOC_MAP.get(beanName));
                        } catch (IllegalAccessException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }
    
        }

### 扫描事务注解 ###

public void doScanTransactional() throws IllegalAccessException, InstantiationException, ClassNotFoundException { 
    
            for (Map.Entry<String, Object> classBeanDefinitionEntry : IOC_MAP.entrySet()) { 
                Object beanDefinition = classBeanDefinitionEntry.getValue();
                //判断生成代理对象
                Object proxy = getProxy(beanDefinition);
                if (proxy==null){ 
                    proxy = beanDefinition;
                }
                //更新bean
                IOC_MAP.put(classBeanDefinitionEntry.getKey(), proxy);
            }
    
    
        }

判断选择哪个代理实现方式 根据是否实现接口

public Object getProxy(Object aClass) { 
            Object jdkProxy = null;
    
            Transactional annotation =  aClass.getClass().getDeclaredAnnotation(Transactional.class);
                if (Objects.nonNull(annotation)) { 
                    //有接口使用jdk动态代理
                     if (aClass.getClass().getInterfaces() == null || aClass.getClass().getInterfaces().length <= 0) { 
    
                        //cglib动态代理
                        jdkProxy = ProxyFactory.getCglibProxy(aClass);
                    } else { 
                        /*for (Class anInterface : aClass.getClass().getInterfaces()) { System.out.println(anInterface.getSimpleName()); }*/
                        jdkProxy = ProxyFactory.getJdkProxy(aClass);
                    }
            }
          return jdkProxy;
    
        }

代理对象实现 以及方法执行前后处理事务

/** * 代理类工厂 * * @author Pilgrim */
    public class ProxyFactory { 
    
        /** * 事务管理器 */
      private final TransferServiceManager t = TransferServiceManager.get();
    
        /** * Jdk动态代理 * * @param obj 被代理的对象 * @return 返回代理对象 */
        public static Object getJdkProxy(Object obj) { 
    
            Object o = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() { 
                @Override
                public Object invoke(Object o, Method method, Object[] objects) throws Throwable { 
    
                    Object invoke = null;
                    try { 
                        // 开启事务(关闭事务的自动提交)
                        TransferServiceManager.get().start();
                        invoke = method.invoke(obj, objects);
                        // 提交事务
                        TransferServiceManager.get().commit();
                    } catch (Exception e) { 
                        e.printStackTrace();
                        // 回滚事务
                        TransferServiceManager.get().rowback();
                        throw e;
                    }
    
                    return invoke;
                }
            });
    
            return o;
    
        }
    
    
        /** * cglib动态代理 * * @param object 被代理的对象 * @return 返回代理对象 */
        public static Object getCglibProxy(Object object) { 
    
            //生成代理对象
            return Enhancer.create(object.getClass(), new MethodInterceptor() { 
    
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                    Object result = null;
                    try { 
    
                        //开启事务
                        TransferServiceManager.get().start();
    
                        result = method.invoke(object, objects);
    
                        //提交事务
                        TransferServiceManager.get().commit();
                    } catch (Exception e) { 
                        //回滚事务
                        TransferServiceManager.get().rowback();
                        throw e;
                    }
                    return result;
    
                }
            });
    
        }

### 初始化方法步骤 ###

/** * 初始化bean * 1 递归扫描包获取类权限定命名 * 2 实例化bean * 3 依赖注入 * 4 扫描事务注解 生成代理对象 * * @param packName * @throws UnsupportedEncodingException */
        public void initBeanFactory(String packName) throws UnsupportedEncodingException, InstantiationException, IllegalAccessException, ClassNotFoundException { 
    
            if (Objects.isNull(packName) || packName.length() == 0) { 
                throw new RuntimeException("无效的包路径");
            }
            packName = packName.replace(".", File.separator);
            URL resource = AnnotationBeanFactory.class.getClassLoader().getResource(packName);
            String path = resource.getPath();
            //解析中文
            String filePath = URLDecoder.decode(path, "UTF-8");
    
            //解析包成java权限定命名com
            parseFilePackName(packName, stringSet, filePath);
            //实例化bean
            setBean();
    
            //System.out.println(String.format("获取到的bean : %s ", IOC_MAP));
    
            //自动装配
            beanAutoWired();
    
            //扫描事务注解
            doScanTransactional();
    
        }

### 对外提供getBean(方法) ###

实现getBean方法

@Override
        //根据id名获取
        public Object getBean(String id) { 
            if (Objects.nonNull(id) && id.length() > 0) { 
                Object beanDefinition = IOC_MAP.get(id);
                return beanDefinition;
            }
            return null;
        }
    
    
        @Override
        //根据类型获取
        public Object getBean(Class<?> aClass) { 
            if (Objects.isNull(aClass)) { 
                return null;
            }
            return IOC_MAP.get(aClass.getSimpleName());
        }
    
        @Override
        public Object getAllBeanName() { 
            return IOC_MAP.keySet();
        }

### 测试 ###

启动tomcat可以看到启动成功,bean实例化完成  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 2]

在servlet init方法里可以调用看一下

private TransferService transferService  ;
    
        @Override
        public void init() throws ServletException { 
            BeanFactory  beanFactory = new AnnotationBeanFactory();
            transferService= (TransferService)beanFactory.getBean("transferServiceImpl");
            TransferService transferService2  = (TransferService) beanFactory.getBean(TransferService.class);
            super.init();
        }

debug可以看到 根据类型还是id都可以获取到代理之后的bean  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 3]

## 代码仓库 ##

内含讲解视频以及实现思路

https://github.com/pomestyle/Spring\_IOC.git

[Link 1]: https://blog.csdn.net/weixin_38361347/article/details/109828331
[20201205150315551.png]: /images/20221120/2ecf6264f1b6402c81648a01f2c369e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70]: /images/20221120/1b0a446c61894057ac07d884629576c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221120/88669b2cb02747a8b1c44f4a39353326.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020120515552579.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201205155902276.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70