前言：网上的框架学习教程千千万，所以我通过查看别人理解的，以及一些教程总结了我所掌握的spring的知识点，总的来说就是三个知识点，IOC、DI和AOP的使用，所以并没有那么复杂的理论知识点，如果有错的地方接受大佬们指点！
首先：简单了解一下Spring是个什么东西！
Spring是一个轻量级控制反转（IOC）和面向切面（AOP）的容器框架，主要是为了解决企业应用开发的复杂性而诞生的。
现在我们来简单实现一下通过Spring输出HelloWorld：
1、新建一个项目，导入Spring的核心依赖包
传送门：ssm的jar包

2、创建HelloWorld.java文件

package com.java.bean;
public class HelloWorld {

   public void hellowrld(){
      System.out.println("HelloWorld!");
   }

}

3、创建Spring的配置文件，程序就是通过配置文件作为耦合合 bean 的耦合类，这是一个xml文件，取名为spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置service
<bean> 配置需要创建的对象
id ：用于之后从spring容器获得实例时使用的
class ：需要创建实例的全限定类名-->
<bean id="hello" class="com.java.bean.HelloWorld"></bean>
</beans>

3、创建测试类

package com.java.test;
public class TestHelloWorld {
 
public static void main(String[] args) {
	//加载spring配置文件
	ApplicationContext con = new ClassPathXmlApplicationContext("spring.xml");
	//通过bean的id获取需要创建的对象
	HelloWorld test= (HelloWorld)con.getBean("hello");
	test.hellowrld();
 
}
}

一个简单的spring实例就这样完成了，但是这样还没能完全体现出来他的优点，所以我们接下来需要做的就是Spring的第一个概念，ICO容器。

IOC：控制反转，把对象的创建以及各个对象间的关系还有对象的销毁交给Spring容器去管理，在实际代码中无需去手动new 对象，只要从spring容器中拿对象来使用。
我们就先肤浅的理解为不用去new一个对象。

Spring 提供了以下两种不同类型的容器：
Spring BeanFactory 容器：它是最简单的容器，给 DI 提供了基本的支持
Spring ApplicationContext 容器：该容器添加了更多的企业特定的功能，当然我一般都是用这个。

IOC的实例，其实就是刚刚HelloWorld的实例，IOC就是通过配置文件，把我要需要创建的对象，也就是new的对象放到IOC容器里面，至于怎么放，就是我们在配置文件里面写的

<bean id="hello" class="com.java.bean.HelloWorld"></bean>

然后怎么从这个容器里面拿出来，就是通过ApplicationContext 的getBean通过bean的id获取到这个对象。

当然Spring实例化bean一共有三种方式：
第一种就是上面写的通过class实例化，也就是使用类构造器实例化(默认无参数)。
第二种就是使用静态工厂方法实例化(简单工厂模式)。

//factory-method指的是方法名
<bean id="hello" class="com.java.bean.HelloWorld" factory-method="hellowrld">

第三种就是使用实例工厂方法实例化(工厂方法模式)。
这种方式需要结合第一种，写两个bean，并且多添加一个工厂类，在工厂类中返回对象（HelloWorld）的实例

package com.java.bean;
public class HelloWorldFactory {
    public HelloWorld getHello() {
        return new HelloWorld ();
    }
}

第一个bean指向工厂类，获取工厂类的实例，第二个bean则根据第一个bean的工厂类实例，指向factory-method的方法名

<bean class="com.java.HelloWorldFactory " id="HelloWorldFactory "/>
<bean id="helloworld" factory-bean="HelloWorldFactory " factory-method="getHello">

DI：依赖注入，引入IOC容器，利用依赖关系注入的方式，实现对象之间的解耦。简单来讲就是在Spring的配置文件编写bean的时候添加 property把属性注入
我们将第一个例子的对象修改一下：

public class HelloWorld {

   private String message;
   public void setMessage(String message){
      this.message  = message;
   }
   public void hellowrld(){
      System.out.println("HelloWorld!"+message);
   }

在配置文件bean中间添加property属性

<property name="message" value="你好,世界！"/>

这是通过属性的set方法注入，相应的还有按照类型和索引注入，大家了解一下就行。
类型注入

<constructor-arg type="int" value=""></constructor-arg>
<constructor-arg type="String" value=""></constructor-arg>

索引注入

<constructor-arg index="0" value=""></constructor-arg>
<constructor-arg index="1" value=""></constructor-arg>

接下来就是AOP：面向切片编程，面向切面编程的目标就是分离关注点，什么意思呢，就是我们执行一个程序，做一件事，这件事作为一个切点，这件事的前后就是切面，也就是服务，用来服务这个切点事件的服务。例如：开车出门这件事，就是一个切点，而我们要执行这件事需要的条件就是开车前车库的门（我们指自动门）开启，开车出去后车库门关闭，车库门的开启和关闭服务了我们开车出门这件事。
1、定义切点

public class Aop01 {
 
	public void car() {
		System.out.println("开车");
	}
}

2、定义切面

public class Aop02 {
 
	public void befor() {
		System.out.println("车库开门----这是切点前，调用切点时自动在切点前执行服务");
	}
	public void after() {
		System.out.println("车库关门----这是切点后，调用切点时自动在切点后执行服务");
	}
}

3、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
 <!-- 目标对象 (切点)-->
 <bean id="aop01" class="com.spring.aop.Aop01"/>
 <!-- 切面bean（服务） -->
 <bean id="aop02" class="com.spring.aop.Aop02"/>
 <!-- 面向切面编程 -->
 <aop:config>
 <aop:aspect ref="aop02">
  <!-- 定义切点 -->
  <aop:pointcut expression="execution(* *.cat(..))" id="embark"/>
  <!-- 声明前置通知 (在切点方法被执行前调用)-->
  <aop:before method="befor" pointcut-ref="embark"/>
  <!-- 声明后置通知 (在切点方法被执行后调用)-->
  <aop:after method="after" pointcut-ref="embark"/>
 </aop:aspect>
 </aop:config>
</beans>

4、测试

public class TestAop {
 
	public static void main(String[] args) {
		ApplicationContext con = new ClassPathXmlApplicationContext("spring.xml");
		Aop01 aop = (Aop01)con.getBean("aop01");
		aop.cat();
	}
}

以上就是Spring入门的一些基础知识，至于源码那些什么的都不是咱现在这个级别接触的，先掌握使用，然后知道为什么，再去考虑源码实现原理这些。