仿写Spring IOC和AOP，仿写思路和代码讲解

已于 2022-03-21 14:45:05 修改
阅读量650 收藏 1
点赞数
分类专栏： 源码仿写 Spring 文章标签： java Spring IOC AOP
于 2022-03-20 23:31:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46116099/article/details/123620097
版权

前言

因为自己在反射和代理这方面用的不多，所以掌握的不太好，正好在看spring的ioc和aop，这两个机制多多少少都用到了反射，尤其是aop，还用到了代理模式，所以借此机会简单仿写一下spring的ioc和aop，花了两天时间终于做好了，思路我觉得还是比较清晰的，记录在这里吧

源码已上传到GitHub上：Imitate-Spring-IOC-and-AOP

IOC仿写

说明一下，我只仿写了通过配置文件注入的方式，注解的方式等以后我可以也会做出来
如果不太清楚IOC的朋友可以看我写的另外一篇博客：IOC讲解
首先理清一下思路：

  • 肯定要有个实体类，通过配置文件的bean标签和property标签来完成注入
  • 扫描配置文件，找到所有的bean标签，获取到id和class，通过反射实例化bean对象
  • 扫描bean标签下的property，获取到name和value（也可能是ref），也是通过反射的方式把属性注入进去（这里可以用Field来直接注入，也可以用Method来调用set方法注入，还可以通过Constructor来调用构造器完成注入，我做的时候属性的直接注入和set注入都做了，构造器注入的原理也差不多）
  • 注入完成后以id作为key，bean对象作为value注册到一个HashMap中，这个HashMap就相当于IOC中的IOC容器，是单例模式的实现
  • 如果要获取到bean对象的话就是从HashMap中get到bean对象，相当于IOC中的getBean方法

以上就是大体的思路，下面就可以根据思路仿写了

实体类User
就注入int变量、String变量、int数组、String数组和引用类型这几个比较常用的吧，另外一些比如float、char、List、Set就不写了，思路也差不多，记得把set、get、toString加上

public class User {
    private String name;
    private int age;
    private int[] scores;
    private String[] subjects;
    private Book book;

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int[] getScores() {
        return scores;
    }

    public void setScores(int[] scores) {
        this.scores = scores;
    }

    public String[] getSubjects() {
        return subjects;
    }

    public void setSubjects(String[] subjects) {
        this.subjects = subjects;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", scores=" + Arrays.toString(scores) +
                ", subjects=" + Arrays.toString(subjects) +
                ", book=" + book +
                '}';
    }
}

实体类Book

public class Book {
    int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Book{" +
                "number=" + number +
                '}';
    }
}

配置文件applicationContext.xml
保存了我们要注入的值

<beans>
    <bean id="java" class="MySpring.pojo.Book">
        <property name="number" value="22"/>
    </bean>

    <bean id="zzy" class="MySpring.pojo.User">
        <property name="name" value="zzy"/>
        <property name="age" value="20"/>
        <property name="scores">
            <array>
                <value>98</value>
                <value>66</value>
                <value>0</value>
            </array>
        </property>
        <property name="subjects">
            <array>
                <value>数学</value>
                <value>英语</value>
                <value>语文</value>
            </array>
        </property>
        <property name="book" ref="java"/>
    </bean>
</beans>

IOC核心类ScanXml
这个类完成了IOC的核心功能，包括扫描配置文件，生成bean对象，注入属性、注册Bean对象到容器中、getBean方法，注释掉的代码是通过Field直接注入的方式，没有注释掉的是通过Method来set注入的

整体思路：

  1. 使用HashMap作为IOC容器，注册register方法就是调用put方法，获取Bean对象getBean方法就是调用get方法，bean标签的id作为key，Bean对象作为value
  2. 扫描配置文件
  3. 得到bean的id和class
  4. 通过反射实例化Bean对象
  5. 得到property的name和value或者ref
  6. 利用反射得到这个属性和set方法，并获取它们的可访问权限
  7. 为了判断是不是数组属性，获取一下array标签，为空则不是，不为空另作处理
  8. 不是数组属性，如果是value，就直接通过invoke方法调用set方法来注入，如果是ref，先调用getBean方法得到容器中的Bean对象再invoke这个set方法注入
  9. 如果是数组，就先创建一个数组，再获得每个value标签，把每个value加到数组中，最后调用invoke方法调用set方法来注入
  10. 最后调用注册register方法把Bean对象注册到HashMap中
public class ScanXml {
    //作为bean容器
    private Map<String, Object> map = new HashMap<>();

	//实现IOC的核心方法，参数为配置文件路径
    public void Scanning(String classPath) throws Exception {
        //扫描配置文件
        InputStream inputStream = new FileInputStream(classPath);
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        Element root = doc.getDocumentElement();
        NodeList nodes = root.getChildNodes();

        //遍历<bean>
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);
            if (node instanceof Element) {
                Element element = (Element) node;
                //得到bean的id和class
                String id = element.getAttribute("id");
                String className = element.getAttribute("class");
                //根据class路径得到Class对象
                Class beanClass = null;
                try {
                    beanClass = Class.forName(className);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                    return;
                }
                //利用反射实例化bean对象
                Object bean = beanClass.newInstance();
                //得到所有property标签
                NodeList propertyList = element.getElementsByTagName("property");
                //遍历property标签
                for (int j = 0; j < propertyList.getLength(); j++) {
                    Node property = propertyList.item(j);
                    if (property instanceof Element) {
                        //得到property中的name，用来表示是哪个属性
                        String name = ((Element) property).getAttribute("name");
                        //可能是数组注入，所以要get一下array标签
                        Node arrayNode = ((Element) property).getElementsByTagName("array").item(0);
                        //利用反射得到这个属性和可访问权限
                        Field field = bean.getClass().getDeclaredField(name);
                        field.setAccessible(true);
                        //利用反射得到set方法和可访问权限，这里要拼一下字符串来指定你想要的这个set方法
                        Method method = bean.getClass().getDeclaredMethod("set" + (char) (name.charAt(0) - 32) + name.substring(1), field.getType());
                        method.setAccessible(true);
                        //判断是不是数组注入
                        if (arrayNode == null) {
                            //得到每个property中的value和ref，value是属性的值，ref是引用类型的值
                            String value = ((Element) property).getAttribute("value");
                            String ref = ((Element) property).getAttribute("ref");
                            //判断是value还是ref，哪个不为空就是哪个
                            //如果是value
                            if (!value.equals("") && ref.equals("")) {
//                                //判断value的数据类型
//                                if (field.getType().getName().equals("java.lang.String")) {
//                                    field.set(bean, value);
//                                } else if (field.getType().getName().equals("int")) {
//                                    field.set(bean, Integer.parseInt(value));
//                                }
								//判断是String类型还是int类型，这样做的目的是如果是int就需要让value转成int类型
                                if (field.getType().getName().equals("java.lang.String")) {
                                	//如果是String类型的属性，直接invoke这个set方法把value作为参数注入进去
                                    method.invoke(bean, value);
                                } else if (field.getType().getName().equals("int")) {
                                //如果是int类型的属性，先让value转成int类型，再invoke这个set方法注入进去
                                    method.invoke(bean, Integer.parseInt(value));
                                }
                                //如果是ref
                            } else if (!ref.equals("") && value.equals("")) {
                            	//调用一下getBean方法拿到这个引用类型的bean对象，再invoke这个set方法注入
                                method.invoke(bean, getBeanFormMap(ref));
//                                field.set(bean, getBean(ref));
                            } else {
                                throw new IllegalArgumentException("id为" + id + "的bean配置有误");
                            }
                            //如果是数组类型的属性
                        } else {
                            //标识是int数组还是String数组
                            boolean flag = false;
                            //得到多个value标签
                            NodeList valueList = ((Element) arrayNode).getElementsByTagName("value");
                            //根据数组类型创建数组
                            Object arr = Array.newInstance(field.getType().getComponentType(), valueList.getLength());
                            //如果是int数组，把标识改为true
                            if (field.getType().getComponentType().getName().equals("int")) {
                                flag = true;
                            }
                            //遍历每个value节点
                            for (int k = 0; k < valueList.getLength(); k++) {
                                Node valueNode = valueList.item(k);
                                //获取value
                                String value = valueNode.getTextContent();
                                if (value.equals("")) throw new IllegalArgumentException("id为" + id + "的bean配置有误");
                                //把value加到数组中，这里也需要考虑int和String两种情况
                                if (flag) {
                                    Array.set(arr, k, Integer.parseInt(value));
                                } else {
                                    Array.set(arr, k, value);
                                }
                            }
//                            field.set(bean, arr);
							//最后也是invoke这个set方法注入
                            method.invoke(bean, arr);
                        }
                    }
                }
                //前面的工作做完之后，已经得到了一个注入完成的bean对象了，最后将bean对象注册到bean容器中
                register(id, bean);
            }
        }
    }

    //将bean对象注册到bean容器中
    private void register(String id, Object bean) {
        map.put(id, bean);
    }

    //获取bean对象
    public Object getBeanFormMap(String name) throws Exception {
        Object bean = map.get(name);
        if (bean == null) throw new IllegalArgumentException("Bean容器中没有name为" + name + "的bean对象");
        return bean;
    }
}

ClassPathXmlApplicationContext类
这个类的作用是把获取配置文件路径到调用ScanXml类中的Scanning方法这一系列过程封装起来，并提供一个getBean方法来调用ScanXml类中的getBean方法获取到Bean对象，这样我们就可以直接调用ClassPathXmlApplicationContext类中的getBean方法就可以得到Bean对象了，不需要再先获取到配置文件路径再调用Scanning方法最后调用getBean方法了

public class ClassPathXmlApplicationContext extends ScanXml {
    private String classpath;

    public ClassPathXmlApplicationContext(String classpath) {
        this.classpath = Objects.requireNonNull(ScanXml.class.getClassLoader().getResource(classpath)).getFile();
    }

    public Object getBean(String name) throws Exception {
    	//调用ScanXml中的Scanning方法
        Scanning(classpath);
        //调用ScanXml的getBean方法
        return super.getBeanFormMap(name);
    }
}

测试类MyTest
直接调用ClassPathXmlApplicationContext 中的getBean方法就可以得到Bean对象了

public class MyTest {
    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("MySpring/Resource/applicationContext.xml");
        User user = (User) context.getBean("zzy");
        System.out.println(user.toString());
    }
}

测试结果在这里插入图片描述

AOP仿写

是基于上面的IOC来仿写的
实现目标： 通过注解的方法来对IOC生成的Bean对象的方法前后进行功能增强
如果不太清楚AOP的朋友可以看我写的另外一篇博客：AOP讲解
也是先理清一下大致思路：

  • 通过@Aspect、@Pointcut、@Before、@After来自定义切面，@Aspect是用来标识这个类是一个切面类，@Pointcut是标识切入点的，其中的value标识了哪个类的哪个方法作为切入点，@Before和@After是用来标识这个方法是作用在哪里的，value可以是@Pointcut标识的切入点，也可以是直接上切入点，和Spring AOP的用法一样
  • 通过反射获取的自定义的切面类的所有信息，主要用到了getAnnotation方法获得注解的信息，包括切入点，哪个方法是通知方法，是用@Before修饰的还是用@After修饰的
  • 调用ScanXml类的Scanning方法和getBean方法来通过IOC得到这个Bean对象
  • 将上面得到的所有信息都传给通知类，通知类要实现InvocationHandler接口
  • 通过JDK动态代理来得到代理对象，在通知类的invoke方法中利用上面得到的所有信息来判断是否要利用反射调用通知方法以及何处调用

以上就是大体的思路，下面就可以根据思路仿写了

所有注解

//标识这个类是切面类
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Aspect {
    public String value() default "";
}

//记录切入点的注解，value用来记录
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Pointcut {
    String value() default "";
}

//标识这个方法是前置通知方法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Before {
    String value();
}

//标识这个方法是后置通知方法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface After {
    String value();
}

service层的接口和类
测试AOP用的

public interface UserService {
    void add(int i);
    
    void delete();
}

public class UserServiceImpl implements UserService{
    @Override
    public void add(int i) {
        System.out.println("添加了一条数据" + i);
    }

    @Override
    public void delete() {
        System.out.println("删除了一条数据");
    }
}

自定义切面AnnotationPointCut类
@Pointcut注解的value的字符串表示包名.类名.方法名，表示这个包下的这个类的哪个方法是切入点，*表示所有方法，也可以写为一个具体的方法名
@Before和@After表示这个方法是前置或后置通知方法，value可以是包名.类名.方法名，也可也是被@Pointcut修饰的方法名，表示@Pointcut中的value就是切入点

@Aspect
public class AnnotationPointCut {
    @Pointcut("MySpring.service.UserServiceImpl.*")
    public void point(){

    }

    @Before("point()")
    public void before(){
        System.out.println("方法执行前");
    }

    @After("point()")
    public void after(){
        System.out.println("方法执行后");
    }
}

ClassPathXmlApplicationContext类
和上面仿写的IOC用的是同一个，只不过重载了getBean方法，第二个getBean方法的多了一个Class参数，这个参数就是我们自定义的切面类，在这个getBean方法中要通过反射获取到注解的所有信息，最后把这些信息都传到通知类中，利用JDK动态代理生成代理对象，返回代理对象即可，所以大家只要看第二个getBean方法即可

public class ClassPathXmlApplicationContext extends ScanXml {
    private String classpath;

    public ClassPathXmlApplicationContext(String classpath) {
        this.classpath = Objects.requireNonNull(ScanXml.class.getClassLoader().getResource(classpath)).getFile();
    }

    public Object getBean(String name) throws Exception {
        Scanning(classpath);
        return super.getBeanFormMap(name);
    }
	
	//重载getBean方法，参数为自定义切面类
    public Object getBean(String name, Class cl) throws Exception {
    	//切入点的value
        String pointcutName = null;
        //用@Pointcut标识的方法
        Method pointcutMethod = null;
        //前置通知方法
        Method beforeMethod = null;
        //后置通知方法
        Method afterMethod = null;
        //前置通知切入点的value
        String beforeName = null;
        //后置通知切入点的value
        String afterName = null;
        //通过反射获取Aspect注解
        Aspect aspect = (Aspect) cl.getAnnotation(Aspect.class);
        //判断是不是切面类
        if (aspect == null) {
            throw new IllegalArgumentException("该类不是切面类");
        }
        //通过反射得到切面类的所有方法
        Method[] methods = cl.getDeclaredMethods();
        //遍历所有方法
        for (Method method : methods) {
        	//先获取Pointcut注解
            Pointcut pointcut = method.getAnnotation(Pointcut.class);
            if (pointcut != null) {
            	//得到Pointcut注解的方法
                pointcutMethod = method;
                //得到Pointcut注解的value
                pointcutName = pointcut.value();
                break;
            }
        }
        //再次遍历方法
        for (Method method : methods) {
            Boolean flag = null;
            String value = null;
            //获取Before和After注解
            Before before = method.getAnnotation(Before.class);
            After after = method.getAnnotation(After.class);
            if (before != null) {
                flag = true;
                value = before.value();
                //得到前置通知方法
                beforeMethod = method;
            }else if(after != null){
                flag = false;
                value = after.value();
                //得到后置通知方法
                afterMethod = method;
            }
            //如果Before的value是切入点方法，直接将前后置通知的value换成切入点的value
            if (flag != null && pointcutMethod != null && (value.equals(pointcutMethod.getName() + "()"))) {
                if(flag){
                    beforeName = pointcutName;
                }else{
                    afterName = pointcutName;
                }
            //如果Before的value不是切入点方法，直接获取前后置通知的value
            }else{
                if(flag != null){
                    if (flag) {
                        beforeName = value;
                    }else{
                        afterName = value;
                    }
                }
            }
        }
        //调用ScanXml的Scanning方法
        Scanning(classpath);
        //调用ScanXml的getBean方法获取Bean对象 
        Object bean = super.getBeanFormMap(name);
        //把上面得到的所有信息通过构造方法传给通知类Advice中，包括Bean对象，切面类对象，前后置通知方法，前后置通知的value
        Advice advice = new Advice(bean,cl.newInstance(),beforeMethod,beforeName,afterMethod,afterName);
        //jdk动态代理生成代理对象
        Object beanPorxy = AopProxy.getProxy(bean,advice);
        //返回代理对象
        return beanPorxy;
    }
}

通知Advice类

public class Advice implements InvocationHandler {
	//jdk动态代理要用到的bean对象，要在这个对象的方法前后使用aop做增强
    private Object bean;
    //自定义切面类的实例对象
    private Object invocationBean;
    //前置通知方法
    private Method beforeMethod;
    //前置通知value
    private String beforeName;
    //后置通知方法
    private Method afterMethod;
    //后置通知value
    private String afterName;
	
	//构造方法
    public Advice(Object bean, Object invocationBean, Method beforeMethod, String beforeName, Method afterMethod, String afterName) {
        this.bean = bean;
        this.invocationBean = invocationBean;
        this.beforeMethod = beforeMethod;
        this.beforeName = beforeName;
        this.afterMethod = afterMethod;
        this.afterName = afterName;
    }
	
	//jdk动态代理的invoke方法，用来实现aop
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	//要使用aop的类的类名
        String invocationClass = bean.getClass().getSimpleName();
        //前置通知的作用类的名，从value中得到
        String beforeClass = null;
        //后置通知的作用类的名，从value中得到
        String afterClass = null;
        //前置通知的作用方法，从value中得到
        String beforeBeanMethod = null;
        //后置通知的作用方法，从value中得到
        String afterBeanMethod = null;
        //用来存储前置通知的value中的信息，后面要通过split方法分割
        String[] beforeArr;
        //用来存储后置通知的value中的信息，后面要通过split方法分割
        String[] afterArr;
        if(beforeName != null) {
        	//按照.分割字符串
            beforeArr = beforeName.split("\\.");
            for (String before : beforeArr) {
            	//如果某个字符串和使用aop的类名相等，就说明这个通知方法会作用在这个类上
                if(before.equals(invocationClass)){
                    beforeClass = before;
                }
            }
            //把使用aop增强的方法名获取到，位于value的最后面
            beforeBeanMethod = beforeArr[beforeArr.length - 1];
        }
        //和上面的逻辑一样
        if(afterName != null) {
            afterArr = afterName.split("\\.");
            for (String after : afterArr) {
                if(after.equals(invocationClass)){
                    afterClass = after;
                }
            }
            afterBeanMethod = afterArr[afterArr.length - 1];
        }
        //如果IOC获取的Bean的类和前置通知要增强的类一样，并且方法名也一致，就通过反射调用这个方法
        if(beforeMethod != null && beforeClass != null && (beforeBeanMethod != null && (beforeBeanMethod.equals("*") || beforeBeanMethod.equals(method.getName())))){
            beforeMethod.invoke(invocationBean);
        }
        //通过method调用IOC获取的类的方法
        method.invoke(bean,args);
                //如果IOC获取的Bean的类和后置通知要增强的类一样，并且方法名也一致，就通过反射调用这个方法
        if(afterMethod != null && afterClass != null && (afterBeanMethod != null && (afterBeanMethod.equals("*") || afterBeanMethod.equals(method.getName())))){
            afterMethod.invoke(invocationBean);
        }
        return null;
    }
}

测试类MyTest

public class MyTest {
    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("MySpring/Resource/applicationContext.xml");
        //调用重载的那个getBean方法，后面那个参数是切面类
        UserService user = (UserService) context.getBean("userService",AnnotationPointCut.class);
        user.add(666);
        user.delete();
    }
}

测试结果
在这里插入图片描述
修改一下切面类
before方法是前置通知，只增强于UserServiceImpl类的add方法
after方法是后置通知，只增强于UserServiceImpl类的delete方法

@Aspect
public class AnnotationPointCut {
    @Before("com.zzy.service.UserServiceImpl.add")
    public void before(){
        System.out.println("方法执行前");
    }

    @After("com.zzy.service.UserServiceImpl.delete")
    public void after(){
        System.out.println("方法执行后");
    }
}

测试结果
在这里插入图片描述
至此，Spring IOC和AOP的仿写就结束了，本人能力有限，所以可能出现不足之处，欢迎指正
也希望大家可以在GitHub上拉下来自己看一下，思路会更加清楚

仿写Spring框架
weixin_45014721的博客
12-03 349
工作内容，不对外开放
简单仿写Spring AOP
weixin_43289848的博客
03-27 290
导语：由于本人是某大学网络中心java组组长，在和学弟学妹们传授完spring的相关知识之后，看到一脸茫然的他们，仿佛看到自己大一的时候，所以为了帮助学弟学妹更好的了解IOC以及 AOP 两大原理，并且帮助自己更加深层次的学习spring,决定自己简单的仿写这两个功能。这篇是AOP，上一篇是IOC。 源码已在github开源：Github地址 百度云 提取码：zanx 1.前序 由于上次仿写Spring IOC之后，帮学弟学妹讲了一下，收获赞许，说这样一下就好理解多了，于是乎Spring仿写第二弹来了，.
spring源码 基于JDK8仿写spring(持续更新)
qq_34376868的博客
09-05 500
1.自动扫描bean注入 经典入口 /** * @author xzc */ public class Test { public static void main(String[] args) { XzcApplicationContext applicationContext = new XzcApplicationContext(XzcAppConfig.class); UserInterface userService = (UserIn...
Java面试知识点（八十五）仿写Spring 进阶之 AOP和IOC协作
程序员世杰
10-30 673
前置阅读： 仿照 Spring 实现简单的 IOC 仿照 Spring 实现简单的 AOP Spring bean 的生命流程 本文承接上文，来继续说说 IOC 和 AOP 的仿写。在上文中，我实现了一个很简单的 IOC 和 AOP 容器。上文实现的 IOC 和 AOP 功能很单一，且 IOC 和 AOP 两个模块没有整合到一起。IOC 在加载 bean 过程中，AOP 不能对 bean 织...
Spring 深度学习 — 高仿 Spring（AOP）
搬运Gong
05-27 303
通过高仿 Spring AOP功能，了解 AOP 的设计思想及理念。
仿照 Spring 实现简单的 AOP
qq_52324490的博客
12-13 218
一、AOP相关概念 代理模式是 AOP 实现的基础。在介绍 AOP 的实现步骤之前，先引入 Spring AOP 中的一些概念，接下来我们会用到这些概念。 1.通知（Advice） 通知定义了要织入目标对象的逻辑，以及执行时机。 Spring 中对应了 5 种不同类型的通知： 前置通知（Before）：在目标方法执行前，执行通知 后置通知（After）：在目标方法执行后，执行通知，此时不关系目标方法返回的结果是什么 返回通知（After-returning）：在目标方法执行后，执行通知 异常通知（Afte
仿照 Spring 实现简单的 IOC
qq_52324490的博客
12-13 224
一、IOC实现 1.实现步骤 最简单的 IOC 容器只需 4 步即可实现，如下： 加载 xml 配置文件，遍历其中的 标签 获取 标签中的 id 和 class 属性，加载 class 属性对应的类，并创建 bean 遍历 标签中的 标签，获取属性值，并将属性值填充到 bean 中 将 bean 注册到 bean 容器中 2.实现代码 【代码结构】 SimpleIOC // IOC 的实现类，实现了上面所说的4个步骤 SimpleIOCTest // IOC 的测试类 Car
Spring简单仿写，实现基本IOC，依赖注入和AOP 未解决循环依赖
最新发布
09-08
在IT行业中，Spring框架是Java开发中的一个核心组件，它主要负责管理对象的生命周期和对象间的依赖关系。...通过仿写Spring，你将有机会亲身体验这些机制，并从中学习到如何构建一个高效、可扩展的软件系统。
仿写Spring框架实现IOC与AOP及解决循环依赖研究
在仿写Spring的过程中，测试代码会涉及到创建简单的bean，并通过配置的方式注入它们之间的依赖关系。此外，还会实现AOP，即在方法执行前后或抛出异常时插入额外的行为，比如通过日志记录方法调用情况，以此来模拟...
Spring框架仿写demo教程
仿写代码的过程通常包括阅读和理解现有Spring框架的代码，然后尝试在新的项目中重现相似的功能和结构。通过这一过程，开发者能够加深对Spring框架内部机制的理解，并提高解决问题的能力。 在进行Spring仿写时，通常...
仿写简易框架 Spring（五）实现 AOP（类似 aop 包）
菜鸡也有大佬梦
02-26 291
在前面两篇，我们已经成功实现了 Spring 最核心的功能 IOC和DI 以及 MVC： 【Spring】重构–手写Spring核心逻辑（二）实现IOC/DI（beans包） 【Spring】重构–手写Spring核心逻辑（三）实现IOC/DI（context包） 【Spring】重构–手写Spring核心逻辑（四）实现MVC（webmvc包） 从这篇开始，我们就要来实现Spring的另一核心 AOP。 1.配置封装（config包） 下面这些类 AOP 中需要用到的基本组件，是对一些基本信息的封装。
简单仿写Android控件SlidingMenu的实例代码
01-04
SlidingMenu （侧滑菜单形式）在android开发过程中，经常用到，这次我们通过一个简单案例来仿写SlidingMenu 的大体功能，下面 是主要实现的代码： java代码：(重写onTouchEvent方法 处理侧滑菜单处的事件分发机制) public class SlidingMenu extends ViewGroup implements OnClickListener { private View menu; private View main; private int menuWidth; private int downX; private Scroller
Spring简单仿写
m0_52458424的博客
05-07 232
手写简易spring框架，简单实现IoC@Component和依赖注入，简单AOP日志功能
SpringAOP的原理及仿写
weixin_46101560的博客
06-28 264
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。想象下面的场景，开发中在多个模块间有某段重复的代码，我们通常是怎么处理的？显然，没有人会靠“复制粘贴”吧。在传统的面向过程编程中，我们也会将这段代码，抽象成一个方法，然后在需要的地方分别调用这个方法，这样当这段代码需要修改时，我们只需要改变这个方法就可以了。然而需求总是变化的，有一
仿写SpringMvc底层源码
qq_31859365的博客
04-07 1257
     一直没有记笔记的习惯，就在此时，决定将自己每一次进步都记录下来。经过几次国内大公司面试。目前而言：对java的理解是停留在运用框架和中间件的层次上，对于底层原理并没有深刻去理解。所以让我决定重新学习java的想法。花了一点时间，将springMvc从底层进行了简单分析。从web.xml，配置加载，常用注解，我们将底层重新进行简单的开发，目的了解spring的底层思想。首先从几个题目出发：...
从0开始仿写一个SpringMvc框架（1）
qq_30765051的博客
10-12 460
仿写SpringMvc（简单版）要实现的功能：扫描注解、控制反转、实现BeanFactory、整合tomcat、实现DispatcherServlet。 本项目基于idea开发 1、建立项目，新建一个maven工程导入相关依赖，主要是tomcat的依赖和配置打成jar包后程序的入口 <dependencies> <dependency> ...
Spring源码仿写pro
weixin_56289362的博客
04-23 248
宝子们，在前面写过一片简单的springIOC仿写，感觉太简单了，只是简单的理解过程，现在基于源码又写一份源码，Atuowire ，Componen，Scope 等等注解均进行了实现，单例多例的实现，依赖注入，初始化方法，AOP的proxy动态代理，Cjlib代理正在实现，更新完成我会立马上传，每一步都有详细的注释欢迎来踩，附源码Zth的源码库 截图代码 部分源码 public Object getBean(String beanName) { BeanDefinition .
冲高级——篇五 之 Spring源码冲冲冲 （仿写Spring及源码剖析）
JavaCoder_juejue的博客
04-26 277
(1)注解编程API (2)手写简易版DispatcherServlet(待添加)
python仿写print_求助，用python仿写以下代码
weixin_39700220的博客
12-04 161
public static void main(String[] args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();int[] flag=new int[29];float[] a=new float[29];for(int i=0;ia[i]=(float)1.0/(float)(i+2);}for(int j=1;j<...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值