spring源码

最新推荐文章于 2023-05-25 19:52:20 发布
最新推荐文章于 2023-05-25 19:52:20 发布
阅读量90 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengyingsuixu/article/details/85164048
版权

BeanDefinition

 

package com.lv.spring.bean;

import org.springframework.util.StringUtils;

import java.util.List;

/**
 * Created by lvyanghui
 * 2018/11/28 9:35
 */
public interface BeanDefinition {


    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";

    Class<?> getBeanClass();

    String getScope();

    boolean isSingleton();
    boolean isPrototype();

    String getFactoryBeanName();
    String getFactoryMethodName();

    String getInitMethodName();

    String getDestroyMethodName();

    List<PropertyValue> getConstructorValues();

    List<PropertyValue> getPropertyValues();

    default boolean validate(){

        if(this.getBeanClass() == null){
            if(StringUtils.isEmpty(this.getFactoryBeanName()) || StringUtils.isEmpty(this.getFactoryMethodName())){
                return false;
            }
        }else{
            if(!StringUtils.isEmpty(this.getFactoryBeanName())){
                return false;
            }
        }
        return true;
    }

}

 

BeanDefinitionRegistry

 

package com.lv.spring.bean;

/**
 * Created by lvyanghui
 * 2018/12/19 14:23
 */
public interface BeanDefinitionRegistry {

    void registerBeanDefinition(String beanName,BeanDefinition beanDefinition)throws BeanDefinitionRegistryException;

    BeanDefinition getBeanDefinition(String beanName);

    boolean containsBeanDefinition(String beanName);
}

BeanDefinitionRegistryException

package com.lv.spring.bean;

/**
 * Created by lvyanghui
 * 2018/12/20 11:07
 */
public class BeanDefinitionRegistryException extends Exception{


    public BeanDefinitionRegistryException(){
        super();
    }

    public BeanDefinitionRegistryException(Throwable cause){
        super(cause);
    }

    public BeanDefinitionRegistryException(String message){
        super(message);
    }

    public BeanDefinitionRegistryException(String message,Throwable cause){
        super(message,cause);
    }
}

 

 

BeanFactory

 

package com.lv.spring.bean;

/**
 * Created by lvyanghui
 * 2018/12/19 14:21
 */
public interface BeanFactory {

    Object getBean(String beanName) throws Exception;
}

BeanRefernerce

package com.lv.spring.bean;

/**
 * Created by lvyanghui
 * 2018/12/21 10:10
 */
public class BeanRefernerce {

    private String name;

    public BeanRefernerce(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

 

DefaultBeanFactory

 

package com.lv.spring.bean;

import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by lvyanghui
 * 2018/12/19 14:50
 */
public class DefaultBeanFactory implements BeanFactory,BeanDefinitionRegistry,Closeable {

    private Map<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
    private Map<String,Object> beanMap = new ConcurrentHashMap<String,Object>(256);

    @Override
    public void registerBeanDefinition(String beanName,BeanDefinition beanDefinition) throws BeanDefinitionRegistryException{

        Objects.requireNonNull(beanName,"beanName不能为空!");
        Objects.requireNonNull(beanDefinition,"beanDefinition不能为空!");

        if(!beanDefinition.validate()){
            throw new BeanDefinitionRegistryException("验证beanDefinition参数不合法");
        }
        if(beanDefinitionMap.containsKey(beanName)){
            throw new BeanDefinitionRegistryException("已经存在beanDefinition");
        }

        beanDefinitionMap.put(beanName,beanDefinition);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public Object getBean(String beanName) throws Exception{
        return doGetBean(beanName);
    }


    public Object doGetBean(String beanName) throws Exception {
        Objects.requireNonNull(beanName,"beanName不能为空");

        Object instance = beanMap.get(beanName);
        if(null != instance){
            return instance;
        }

        BeanDefinition beanDefinition = getBeanDefinition(beanName);
        Objects.requireNonNull(beanDefinition, "beanDefinition不能为空");

        Class<?> classType = beanDefinition.getBeanClass();
        if(classType != null){

            if(beanDefinition.getFactoryMethodName() == null){
                instance = createInstanceByConstructor(beanDefinition);
            }else{
                instance = createInstanceByStaticFactoryMethod(beanDefinition);
            }
        }else{
            instance = createInstanceByFactoryMethod(beanDefinition);
        }

        doInitMethod(beanDefinition,instance);

        if(beanDefinition.isSingleton()){
            beanMap.put(beanName,instance);
        }

        return instance;
    }

    public Object createInstanceByConstructor(BeanDefinition beanDefinition)throws Exception{

        Class<?> classType = beanDefinition.getBeanClass();
        Object[] args = getRealValues(beanDefinition.getConstructorValues());
        if(null == args){
            return classType.newInstance();
        }else{
            Constructor constructor = determinConstructor(beanDefinition,args);
            if(null == constructor){
                return classType.newInstance();
            }else{
                return constructor.newInstance(args);
            }
        }
    }

    public Object createInstanceByStaticFactoryMethod(BeanDefinition beanDefinition)throws Exception{

        Class<?> classType = beanDefinition.getBeanClass();
        Object[] args = getRealValues(beanDefinition.getConstructorValues());
        Method method = determinMethod(beanDefinition,args,classType);
        return method.invoke(classType,args);
    }

    public Object createInstanceByFactoryMethod(BeanDefinition beanDefinition)throws Exception{

        Object factoryBean = doGetBean(beanDefinition.getFactoryBeanName());
        Object[] args = getRealValues(beanDefinition.getConstructorValues());
        Method method = determinMethod(beanDefinition, args,factoryBean.getClass());

        return method.invoke(factoryBean,args);
    }

    public void doInitMethod(BeanDefinition beanDefinition,Object instance) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        String initMethod = beanDefinition.getInitMethodName();
        if(!StringUtils.isEmpty(initMethod)){
            Method method = instance.getClass().getMethod(initMethod, null);
            method.invoke(instance,null);
        }
    }

    public Constructor<?> determinConstructor(BeanDefinition beanDefinition,Object[] args)throws Exception{

        Constructor<?>[] constructors = beanDefinition.getBeanClass().getConstructors();
        outer: for(Constructor constructor : constructors){

            Class[] parameterTypes = constructor.getParameterTypes();
            int i = 0;
            if(parameterTypes.length == args.length){
                for(Object arg : args){

                    if(!parameterTypes[i++].isAssignableFrom(arg.getClass())){
                        continue outer;
                    }
                    if(i == args.length){
                        return constructor;
                    }
                }
            }
        }

        return null;
    }

    public Method determinMethod(BeanDefinition beanDefinition,Object[] args,Class<?> classType)throws Exception{

        Method method = null;

        if(null == args){
            method = classType.getMethod(beanDefinition.getFactoryMethodName());
        }
        Method[] methods = classType.getMethods();

        outer: for(Method me : methods){
            if(!me.getName().equals(beanDefinition.getFactoryMethodName())){
                continue ;
            }else{
                Class<?>[] parameterTypes = me.getParameterTypes();
                int i = 0;
                if(args.length == parameterTypes.length){
                    for(Object arg : args){
                        if(!parameterTypes[i++].isAssignableFrom(arg.getClass())){
                            continue outer;
                        }

                        if(i == args.length){
                            return me;
                        }
                    }
                }
            }
        }
        if(null == method){
            throw new Exception("找不到方法");
        }
        return method;
    }

    public Object[] getRealValues(List<PropertyValue> propertyValues)throws Exception{

        Object[] realValues = null;
        if(!CollectionUtils.isEmpty(propertyValues)){
            List<PropertyValue> resolvedPropertyValues = resolvePropertyValues(propertyValues);
            realValues = new Object[resolvedPropertyValues.size()];
            for(int i = 0,len = resolvedPropertyValues.size(); i < len; i++){
                realValues[i] = resolvedPropertyValues.get(i).getValue();
            }
        }
        return realValues;
    }


    public List<PropertyValue> resolvePropertyValues(List<PropertyValue> propertyValues)throws Exception{


        List<PropertyValue> resolvedPropertyValues = new ArrayList<>();

        Object value = null;
        for(PropertyValue propertyValue : propertyValues){

            value = propertyValue.getValue();

            if(value instanceof BeanRefernerce){
                propertyValue.setValue(getBean(((BeanRefernerce) value).getName()));
            }else if(value instanceof String){
                propertyValue.setValue(String.valueOf(value));
            }else if(value instanceof Integer){

            }else if(value instanceof List){

            } else if(value instanceof Map){

            }

            resolvedPropertyValues.add(propertyValue);
        }
        return resolvedPropertyValues;
    }

    @Override
    public void close() throws IOException {
        //执行单例实例的销毁方法

        for(Map.Entry<String,BeanDefinition> entry : beanDefinitionMap.entrySet()){
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();

            if(beanDefinition.isSingleton() && !StringUtils.isEmpty(beanDefinition.getDestroyMethodName())){

                Object instance = beanMap.get(beanName);
                try {
                    Method method = instance.getClass().getMethod(beanDefinition.getDestroyMethodName(),null);

                    method.invoke(instance,null);

                } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

GenericBeanDefinition

 

package com.lv.spring.bean;

import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by lvyanghui
 * 2018/12/19 14:42
 */
public class GenericBeanDefinition implements BeanDefinition{

    private Class<?> beanClass;
    private String scope=SCOPE_SINGLETON;
    private String factoryBeanName;
    private String factoryMethodName;
    private String initMethodName;
    private String destroyMethodName;

    private List<PropertyValue> constructorValues = new ArrayList<>();
    private List<PropertyValue> propertyValues = new ArrayList<>();

    public void setBeanClass(Class<?> beanClass) {
        this.beanClass = beanClass;
    }

    public void setScope(String scope) {
        if(!StringUtils.isEmpty(scope)){
            this.scope = scope;
        }
    }

    public void setFactoryBeanName(String factoryBeanName) {
        this.factoryBeanName = factoryBeanName;
    }

    public void setFactoryMethodName(String factoryMethodName) {
        this.factoryMethodName = factoryMethodName;
    }

    public void setInitMethodName(String initMethodName) {
        this.initMethodName = initMethodName;
    }

    public void setDestroyMethodName(String destroyMethodName) {
        this.destroyMethodName = destroyMethodName;
    }

    public void setConstructorValues(List<PropertyValue> constructorValues) {
        this.constructorValues = constructorValues;
    }

    public void setPropertyValues(List<PropertyValue> propertyValues) {
        this.propertyValues = propertyValues;
    }

    @Override
    public Class<?> getBeanClass() {
        return beanClass;
    }

    @Override
    public String getScope() {
        return scope;
    }

    @Override
    public boolean isSingleton() {
        return SCOPE_SINGLETON.equals(scope);
    }

    @Override
    public boolean isPrototype() {
        return SCOPE_PROTOTYPE.equals(scope);
    }

    @Override
    public String getFactoryBeanName() {
        return factoryBeanName;
    }

    @Override
    public String getFactoryMethodName() {
        return factoryMethodName;
    }

    @Override
    public String getInitMethodName() {
        return initMethodName;
    }

    @Override
    public String getDestroyMethodName() {
        return destroyMethodName;
    }


    @Override
    public List<PropertyValue> getConstructorValues() {
        return constructorValues;
    }

    @Override
    public List<PropertyValue> getPropertyValues() {
        return propertyValues;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        GenericBeanDefinition that = (GenericBeanDefinition) o;

        if (!beanClass.equals(that.beanClass)) return false;
        if (!destroyMethodName.equals(that.destroyMethodName)) return false;
        if (!factoryBeanName.equals(that.factoryBeanName)) return false;
        if (!factoryMethodName.equals(that.factoryMethodName)) return false;
        if (!initMethodName.equals(that.initMethodName)) return false;
        if (!scope.equals(that.scope)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = beanClass.hashCode();
        result = 31 * result + scope.hashCode();
        result = 31 * result + factoryBeanName.hashCode();
        result = 31 * result + factoryMethodName.hashCode();
        result = 31 * result + initMethodName.hashCode();
        result = 31 * result + destroyMethodName.hashCode();
        return result;
    }


}

 

PropertyValue

 

package com.lv.spring.bean;

/**
 * Created by lvyanghui
 * 2018/12/21 9:47
 */
public class PropertyValue {

    private String name;
    private Object value;

    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

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

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

 

ABean

 

package com.lv.spring.test;

/**
 * Created by lvyanghui
 * 2018/12/19 16:44
 */
public class ABean {

    public void initMethod(){

        System.out.println("ABean 执行初始化方法.....");
    }

    public void methodA(){
        System.out.println("ABean 执行methodA.......");
    }

    public void destoryA(){
        System.out.println("ABean 执行destoryA.......");
    }


}

 

ABeanFactory

 

package com.lv.spring.test;

/**
 * Created by lvyanghui
 * 2018/12/19 16:44
 */
public class ABeanFactory {


    public static ABean getBeanByFactory(){

        return new ABean();
    }

    public ABean getBeanByFactoryBean(){

        return new ABean();
    }

}

 

BBean

 

package com.lv.spring.test;

/**
 * Created by lvyanghui
 * 2018/12/19 16:44
 */
public class BBean {

    private String name;

    private ABean aBean;

    public BBean() {
    }

    public BBean(String name) {
        this.name = name;
    }

    public BBean(String name, ABean aBean) {
        this.name = name;
        this.aBean = aBean;
    }

    public String getName() {
        return name;
    }

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

    public ABean getaBean() {
        return aBean;
    }

    public void setaBean(ABean aBean) {
        this.aBean = aBean;
    }
}

BBeanFactory

 

package com.lv.spring.test;

/**
 * Created by lvyanghui
 * 2018/12/19 16:44
 */
public class BBeanFactory {


    public static BBean getBeanByFactory(String name, ABean aBean){

        return new BBean();
    }

    public BBean getBeanByFactoryBean(String name, ABean aBean,String kk){

        return new BBean();
    }

}

 

BeanFactoryDITest

package com.lv;


import com.lv.spring.bean.BeanRefernerce;
import com.lv.spring.bean.DefaultBeanFactory;
import com.lv.spring.bean.GenericBeanDefinition;
import com.lv.spring.bean.PropertyValue;
import com.lv.spring.test.ABean;
import com.lv.spring.test.BBean;
import com.lv.spring.test.BBeanFactory;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by lvyanghui
 * 2018/12/19 16:46
 */
public class BeanFactoryDITest {

    static DefaultBeanFactory beanFactory = new DefaultBeanFactory();

    @Test
    public void registerConstructorDI()throws Exception{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABean.class);
        beanFactory.registerBeanDefinition("aa", bd);

        bd = new GenericBeanDefinition();
        bd.setBeanClass(BBean.class);

        PropertyValue property1 = new PropertyValue("name","lvyanghui");
        BeanRefernerce beanRefernerce = new BeanRefernerce("aa");
        PropertyValue property2 = new PropertyValue("ref",beanRefernerce);

        PropertyValue property3 = new PropertyValue("kkk","ssdfsdf");
        List<PropertyValue> propertyValues = new ArrayList<>();
        propertyValues.add(property1);
        propertyValues.add(property2);
        propertyValues.add(property3);
        bd.setConstructorValues(propertyValues);

        beanFactory.registerBeanDefinition("bb",bd);

        BBean bBean = (BBean)beanFactory.getBean("bb");
        System.out.println(bBean);

    }

    @Test
    public void registerStaticFactoryMethod()throws Exception{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABean.class);
        beanFactory.registerBeanDefinition("aa", bd);

        bd = new GenericBeanDefinition();
        bd.setBeanClass(BBeanFactory.class);
        bd.setFactoryMethodName("getBeanByFactory");

        PropertyValue property1 = new PropertyValue("name","lvyanghui");
        BeanRefernerce beanRefernerce = new BeanRefernerce("aa");
        PropertyValue property2 = new PropertyValue("ref",beanRefernerce);

        //PropertyValue property3 = new PropertyValue("kkk","ssdfsdf");
        List<PropertyValue> propertyValues = new ArrayList<>();
        propertyValues.add(property1);
        propertyValues.add(property2);
        //propertyValues.add(property3);
        bd.setConstructorValues(propertyValues);

        beanFactory.registerBeanDefinition("factoryMethod",bd);

        BBean bBean = (BBean)beanFactory.getBean("factoryMethod");
        System.out.println(bBean);
    }

    @Test
    public void registerFactoryMethod()throws Exception{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABean.class);
        beanFactory.registerBeanDefinition("aa", bd);

        bd = new GenericBeanDefinition();
        bd.setBeanClass(BBeanFactory.class);
        String fbname = "factory";
        beanFactory.registerBeanDefinition(fbname, bd);

        bd = new GenericBeanDefinition();
        bd.setFactoryBeanName(fbname);
        bd.setFactoryMethodName("getBeanByFactoryBean");

        PropertyValue property1 = new PropertyValue("name","lvyanghui");
        BeanRefernerce beanRefernerce = new BeanRefernerce("aa");
        PropertyValue property2 = new PropertyValue("ref",beanRefernerce);

        PropertyValue property3 = new PropertyValue("kk","ssdfsdf");
        List<PropertyValue> propertyValues = new ArrayList<>();
        propertyValues.add(property1);
        propertyValues.add(property2);
        propertyValues.add(property3);
        bd.setConstructorValues(propertyValues);

        beanFactory.registerBeanDefinition("factoryBean",bd);

        BBean bBean = (BBean)beanFactory.getBean("factoryBean");
        System.out.println(bBean);


    }
}

 

BeanFactoryTest

 

package com.lv;


import com.lv.spring.bean.BeanDefinitionRegistryException;
import com.lv.spring.bean.DefaultBeanFactory;
import com.lv.spring.bean.GenericBeanDefinition;
import com.lv.spring.test.ABean;
import com.lv.spring.test.ABeanFactory;
import org.junit.AfterClass;
import org.junit.Test;

/**
 * Created by lvyanghui
 * 2018/12/19 16:46
 */
public class BeanFactoryTest {

    static DefaultBeanFactory beanFactory = new DefaultBeanFactory();

    @Test
    public void register()throws BeanDefinitionRegistryException{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABean.class);
        //bd.setScope("singleton");
        //bd.setScope("prototype");
        bd.setInitMethodName("initMethod");
        beanFactory.registerBeanDefinition("aa", bd);
    }

    @Test
    public void registerStaticFactoryMethod()throws BeanDefinitionRegistryException{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABeanFactory.class);
        bd.setFactoryMethodName("getBeanByFactory");

        beanFactory.registerBeanDefinition("bb", bd);
    }

    @Test
    public void registerFactoryMethod()throws BeanDefinitionRegistryException{

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABeanFactory.class);
        String fbname = "factory";
        beanFactory.registerBeanDefinition(fbname, bd);

        bd = new GenericBeanDefinition();
        bd.setFactoryBeanName(fbname);
        bd.setFactoryMethodName("getBeanByFactoryBean");
        beanFactory.registerBeanDefinition("factoryBean",bd);

    }

    @AfterClass
    public static void testFactory()throws Exception{

        System.out.println("spring 构造方式------------");
        for (int i = 0; i < 3; i++) {
            ABean abean = (ABean)beanFactory.getBean("aa");
            System.out.println(abean);
        }


        System.out.println("spring 静态工厂方式------------");
        for (int i = 0; i < 3; i++) {
            ABean abean = (ABean)beanFactory.getBean("bb");
            System.out.println(abean);
        }

        System.out.println("spring 工厂方法方式------------");
        for (int i = 0; i < 3; i++) {
            ABean abean = (ABean)beanFactory.getBean("factoryBean");
            System.out.println(abean);
        }
    }
}

 

 

fengyingsuixu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【spring】spring源码搭建
自天祐之，吉，无不利。
02-17 701
【spring】spring源码搭建
如何搭建Spring源码阅读项目，基于5.2.x版本
热门推荐
scoful的专栏
09-23 6万+
目录1. 唠叨两句2. 查看源码的gradle版本3. 下载源码3.1 源码地址3.2 通过gitee中转3.2.1 进去github源码地址，复制URL3.2.2 进入gitee，选择右上角加号，选择从GitHub/GitLab导入仓库3.2.3 粘贴复制的github地址到第一栏,然后为自己的仓库命名3.2.4 下载gitee代码到本地文件夹中3.2.4.1 选择稳定的5.2.x版本，复制地址3.2.4.2 命令行下载源码到本地文件夹4. 加载进IDEA4.1 IDEA操作:File--> OPE
Spring源码概述
ai15013602354的博客
06-26 2277
spring源码博大精深，通过学习领略spring源码的设计思想，一定会让你更进一步。本篇是spring源码的第一篇-spring源码概述(主要讲spring ioc)
Spring源码全解析，帮你彻底学习Spring源码
chenxuyuana的博客
03-11 965
我们每天都和代码打交道。经过数年的基础教育和职业培训，大部分程序员都会「写」代码，或者至少会抄代码和改代码。但是，会读代码的并不在多数，会读代码又真正读懂一些大项目的源码的，少之又少。这种怪状，真要追究起来，怪不得程序员这个群体本身 —— 它是两个原因造成的：
Spring源码编译
weixin_39786760的博客
06-05 2280
Spring Framework 源码编译步骤，涉及到软件包括ideal、maven、grandle、git等开发工具
01-Spring源码-源码概述
zql1455890112的博客
08-27 911
spring源码
IDEA 导入 spring 源码
xhmico的博客
05-12 4860
我们在学习 spring 源码的时候，有时候是需要在阅读源码的时候添加一些代码注释，或者是对源码的一些感悟，如果没有将 spring 的源码导入到 IDEA 中，单纯是通过 Maven 去阅读 jar 的形式是无法添加一些注释信息的，即便可以通过一些比如像这样的插件做到在源代码中添加注释，但还是有局限性的，首先这个插件不允许你更改源码的行数，所以你的私人注释只能写在一行里，其次导入源代码，你可以更改源代码比如说打印一些东西，都是更有助于去理解源码的。
如何编译 Spring 源码？
swadian2008的博客
04-28 3936
目录 1、源码下载 2、构建工具准备 3、编译compileTestJava模块 4、导入项目到IDEA中 5、添加 gradle 模块 本示例基于 spring-framework-5.2.7.RELEASE + GradleWapper + jdk1.8.0_131编译 1、源码下载 从官网下载源码：Spring Framework 选择具体的稳定版本(RELEASE)即可 2、构建工具准备 安装源码对应的 gradle 版本（也可不安装），建议使用 gradleWrape
Idea导入Spring源码
qq_43372633的博客
05-25 1750
Idea导入Spring源码，下载，安装，导入一步到位！新手都可以导入成功！
Spring源码学习---------(最简单易懂的源码学习笔记)
奇点
07-05 1万+
前沿 工作一段时间了，之前一直想学习一下spring的源码，最近有时间学习了一下。现在把最近学习的成果整理一下，也向大家分享一下。 下面是spring源码的学习笔记，仅供参考。本人能力有限，难免会出现问题，欢迎各位大佬指出。 读源码的方法： 之前只是看过JDK的一些源码，像是spring和springboot等源码只是简略的看过，并没有系统的学习过，同时，这么优秀的作品很是值得我们学习的。抱着好奇心开始了读spring源码的道路，废话不多说，这里把我的学习笔记分享给大家。 读源码首先找...
spring源码中英文注释
01-12
这个压缩包文件中的"spring源码 中英文注释"为开发者提供了一个深入理解Spring框架内部工作原理的机会。通过阅读源码和注释，我们可以更清晰地了解Spring如何管理依赖注入、AOP（面向切面编程）、事务管理、上下文...
Spring源代码解析
12-30
同时，了解Spring源码也有助于开发者更好地选择和集成其他Java库，提升开发效率和应用性能。 总结来说，Spring源代码解析涵盖了IoC容器的运作、AOP的实现、数据访问的策略以及Web MVC的流程。深入研究这些内容，将...
Spring源码深度解析第二版
11-15
Spring源码深度解析第二版 Spring是一款广泛应用于Java企业级应用程序的开源框架，旨在简化Java应用程序的开发和部署。Spring框架的核心主要包括了IoC容器、AOP、MVC框架等模块。 第1章 Spring整体架构和环境搭建 ...
spring源码雷神spring源码雷神
08-06
- `src`目录包含源代码，通常分为`main/java`和`test/java`，分别存放主代码和测试代码。 - `.idea`是IntelliJ IDEA的工作区配置文件。 对于想要深入理解Spring源码的开发者来说，通常会从这些文件入手，结合源码...
mybatis自动生成xml等文件
fengyingsuixu的博客
01-23 1637
  GenerateParamsUtil类 import java.io.*; import java.sql.*; import java.text.SimpleDateFormat; import java.util.*; import java.util.Date; /** * cmbxb 55.12.221.63/55.12.205.225 3306 app_usr/App_u...
spring手写源码一
fengyingsuixu的博客
01-16 494
分为三个包 aop包、bean包、samples包 aop包含advice、advisor、pointcut和各个类 advice包 Advice类 package com.lv.spring.aop.advice; /** * Created by lvyanghui * 2018/12/25 14:38 */ public interface Advice { } Af...
netty3.10.5尝试
fengyingsuixu的博客
01-23 456
ClientHandler package com.lv.netty; import org.jboss.netty.channel.*; /** * Created by LocalUser on 2018/1/24. */ public class ClientHandler extends SimpleChannelHandler { @Override publ...
redis使用
fengyingsuixu的博客
01-23 246
JedisUtil package com.lv.redis; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; /** * Created by lvyanghui * 2018/6/14 16:40 ...
spring源码debug
最新发布
02-28
要进行Spring源码的调试，你可以按照以下步骤进行操作： 1. 下载Spring源码：你可以从Spring官方网站或GitHub上获取Spring框架的源码。下载并解压源码包。 2. 导入源码到IDE：使用你喜欢的集成开发环境（IDE），如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值