一文学会Spring,Spring最简单的入门教程（万字好文）

最新推荐文章于 2024-04-20 11:01:50 发布
最新推荐文章于 2024-04-20 11:01:50 发布
阅读量8.7k 收藏 178
点赞数 43
分类专栏： spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ypxcan/article/details/126108069
版权

1.Spring概述

1.1 Spring框架是什么

​ Spring是与2003年兴起的一个轻量级的Java开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring的核心是控制反转(IOC)和面向切面编程(AOP)。Spring是可以在Java SE/EE中使用的轻量级开源框架。

​ Spring的主要作用就是为代码"解耦"，降低代码间的耦合度。就是让对象和对象(模板和模板)之间关系不是使用代码关联，而是通过配置来说明。即在Spring中说明对象(模块)的关系。

​ Spring根据代码的功能特点，使用IOC降低业务对象之间耦合度。IOC使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了，而是由Spring容器统一管理，自动"注入"，注入即赋值。而AOP使得系统服务得到了最大复用，且不用再由及程序手工将系统及服务"混杂"到主业务逻辑中了，而是由Spring容器统一完成

1.2 Spring优点

1.2.1 轻量

​ Spring框架使用的jar都比较小，一般在1M以下或者几百kb。Spring核心功能所需的jar包总共在3M左右

​ Spring框架运行占用的资源少，运行效率高。不依赖其他jar包

1.2.2 针对接口编程，解耦合

​ Spring提供了IoC控制反转，由容器管理对象，对象的依赖关系。原来在程序代码中的对象创建方式，现在由容器完成。对象之间的依赖解耦合。

1.2.3 AOP编程的支持

​ 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

1.2.4 方便集成各种优秀框架

​ Spring不排斥各种优秀的开源框架，相反Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架(如 Sruts,Hibernate,MyBatis)等的直接支持，简化框架的使用。

2 IoC控制反转

2.1 概念

IoC,Inversion of Control：控制反转，是一个理论，一个指导思想。指导开发人员如何使用对象，管理对象的。把对象的创建，属性赋值，对象的生命周期都交给代码之外的容器管理。

1.IoC分为控制和反转

控制：对象创建，属性赋值，对象生命周期管理

反转：把开发人员管理对象的权限转移给了代码之外的容器实现。由容器完成对象的管理。

正转：开发人员在代码中，使用new构造方法创建对象。开发人员掌握了对象的创建，属性赋值，对象从开始到销毁的全部过程。开发人员有对 对象的全部控制。

通过容器，可以使用容器中的对象(容器已经创建了对象，对象属性赋值了，对象也组装好了)

2.IoC技术的实现

DI(依赖注入)：Dependency Injection，缩写是DI。是IoC的一种技术实现。程序只需要提供要使用的对象的名称就可以了。对象如何创建，如何从容器中查找，获取都是由容器内部自己实现。

依赖名词：比如说ClassA类使用了ClassB的属性或者方法，叫做ClassA依赖ClassB

public class ClassB{
   
    
    public void createOrder() {
   
        
    }
}

public class ClassA{
   
    //属性
    private ClassB b = new ClassB();
    
    public void buy() {
   
        b.createOrder();
    }
}

执行ClassA的buy()
ClassA a = new ClassA();
a.buy();

3.Spring框架使用的DI实现IoC

通过Spring框架，只需要提供要使用的对象名词就可以了。从容器中获取名称对应的对象

Spring底层使用的 反射机制，通过反射创建对象，给属性赋值。

2.2 第一个spring项目

我们来创建第一个Spring项目

1.创建一个空项目

在这里插入图片描述

2.添加新的Module

在这里插入图片描述

我们创建第一个项目，名称为Spring-01,创建完成后，我们来看项目目录结构

在这里插入图片描述

3.加入依赖，修改pom.xml
spring-context：spring依赖
junit：单元测试

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <!--spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.4</version>
        </dependency>
    </dependencies>

4.开发人员定义类：接口和实现类
类也可以没有接口。
接口和实现类定义：和没有spring一样

接口的定义：

public interface SomeService {
   
    void doSome();
}

实现类的定义：

import com.lu.service.SomeService;

public class SomeServiceImpl implements SomeService {
   
    @Override
    public void doSome() {
   
        System.out.println("执行了业务方法doSome()...");
    }
}

5.创建spring的配置文件
作用：声明对象
把对象交给spring创建和管理
使用表示对象生命，一个bean表示一个java对象

<?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">

</beans>

spring标准的配置文件：
1.根标签是 beans
2.beans后面的是约束文件说明
3.beans里面是bean生命
4.什么是bean：bean就是java对象，spring容器管理的java对象，叫做bean

我们来创建一个对象

<?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">

    <!--声明对象
        id:自定义对象名称，唯一值(可以没有，spring可以提供默认名称)
        class:类的全限定名称，spring通过反射机制创建对象，不能是接口

        spring根据id，class创建对象，把对象放入到spring的一个map对象。
        map.put(id,对象)
    -->
    <bean id="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
</beans>

6.使用容器中的对象
创建一个表示spring容器的对象 AppplicationContext
从容器中，根据名称获取对象，使用getBean(“对象名称”)

package com.lu;

import com.lu.service.SomeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
   

    @Test
    public void testdoSomething() {
   
        //SomeService service = new SomeServiceImpl();
        //service.doSome();

        //1.指定spring配置文件：从类路径(classpath)之下开始的路径
        String config="beans.xml";

        //2.创建容器对象 ApplicationContext 表示spring容器对象。通过ctx获取某个java对象
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //3.从容器中获取指定名称的对象，使用getBean("id")
        SomeService service = (SomeService)ctx.getBean("someService");

        //4.调用对象的方法
        service.doSome();
    }
}

我们来运行一下：

在这里插入图片描述

成功运行！

2.3 三个问题的探究

1.我们来思考一个问题，通过spring来创建对象，是调用的类的无参构造函数吗？

我们来测试一下,我们现在实现类中定义一个无参构造方法

package com.lu.service.impl;

import com.lu.service.SomeService;

public class SomeServiceImpl implements SomeService {
   

    public SomeServiceImpl() {
   
        System.out.println("无参构造");
    }

    @Override
    public void doSome() {
   
        System.out.println("执行了业务方法doSome()...");
    }
}

然后在测试类中测试

    //spring创建对象，调用的是类的哪个方法？
    @Test
    public void test01() {
   
        String config = "beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //SomeService service = ctx.getBean(SomeService.class);
        //service.doSome();
        SomeService service = (SomeService) ctx.getBean("someService");
        service.doSome();
    }

控制台输出：
在这里插入图片描述

看来真的是调用了无参构造方法，也就是说spring默认调用的是无参构造方法，也就是说我们在类中有有参构造方法的话，我们必须显示的声明无参构造方法

2.我们再来思考一个问题，spring是在什么时候创建的对象？

我们来写代码测试一下

//spring是在什么时候创建的对象？
@Test
public void test02() {
   
    String config = "beans.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
    //SomeService service = (SomeService) ctx.getBean("someService");
    //service.doSome();
}

我们把后面两行注释掉，跑一下代码

在这里插入图片描述

出来无参构造了，说明对象创建了，也就是说创建spring容器对象的时候，会读取配置文件，创建文件中声明的Java对象

这样做的优点是：

获取对象的速度快，因为对象已经创建好了

缺点：

占用内存

3.我们再来思考第三个问题，spring容器创建对象，一次创建几个呢？

我们来修改一下beans.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">

    <bean id="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
    <bean id="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
</beans>

跑一下测试类

//spring容器创建对象，一次创建几个
@Test
public void test03() {
   
    String config = "beans.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
    //SomeService service = (SomeService) ctx.getBean("someService");
    //service.doSome();
}

输出一下

在这里插入图片描述

我们发现出来两个对象，也就是说：

在创建容器(ApplicationContext)对象时，会把配置文件中的所有对象都创建出来(spring的默认规则)

2.4 spring容器创建对象的特点

1.容器对象ApplicationContext:接口

​ 通过ApplicationContext对象，获取要使用的其他Java对象，执行getBean(“的id”)
2.spring默认时调用类的无参构造方法，创建对象

3.spring读取配置文件，一次创建好所有的Java对象，都放到map中

2.4.1 获取容器中定义的对象信息

我们获取容器中定义的对象信息主要通过两个方法

getBeanDefinitionCount()	//获取容器中定义对象的数量
getBeanDefinitionNames()	//获取容器中定义的对象名称

我们来编写测试类：

@Test
public void test04() {
   
    String config = "beans.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    //获取容器中定义对象的数量
    int nums = ctx.getBeanDefinitionCount();
    System.out.println("容器中定义对象的数量==" + nums);

    //获取容器中定义的对象名称
    String names[] = ctx.getBeanDefinitionNames();
    for (String name :
         names) {
   
        System.out.println("容器中对象的名称==" + name);
    }
}

控制台输出：

在这里插入图片描述

我们可以看到我们已经获取到容器中定义的对象信息。

2.4.2 spring创建非自定义类对象

刚才的例子我们的对象都是创建的自己定义的类的对象，那么spring如何创建非自定义类的对象呢，比如Date类

我们先来修改beans文件

<?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">

    <bean id="mydate" class="java.util.Date"></bean>
</beans>

来编写测试类：

//spring创建非自定义类的对象
//有class就能让spring创建对象
@Test
public void test05() {
   
    String config = "beans.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    Date date = (Date) ctx.getBean("mydate");
    System.out.println("date==" + date);
}

控制台输出：

在这里插入图片描述

我们看到Date类的对象创建成功了

2.4.3 没有接口的类创建对象

上面我们都是创建的有接口的类的对象，那么spring能否创建没有接口的类的对象呢

我们来试验一下，首先创建一个类，该类没有实现接口

package com.lu.service;

public class OtherService {
   
    public void doOther() {
   
        System.out.println("执行OtherService的doOther()");
    }
}

beans.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">
    
    <bean id="otherService" class="com.lu.service.OtherService"></bean>
</beans>

编写测试类：

@Test
public void test06() {
   
    String config = "beans.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    OtherService service = (OtherService) ctx.getBean("otherService");
    service.doOther();
}

控制台输出：

在这里插入图片描述

我们发现创建成功了，也就是说spring创建对象只需要拿到beans文件中的id即可

2.5 DI:属性赋值

spring调用类的无参构造方法，创建对象。对象创建后给属性赋值。

给属性赋值可以使用：

  • xml配置文件中的标签和属性
  • 使用注解

DI分类：

  • set注入，也叫做设值注入
  • 构造注入

2.5.1 基于xml的DI

在xml配置文件中使用标签和属性，完成对象创建，属性赋值

2.5.1.1 set注入，也叫做设值注入

概念：spring调用类中的set方法，在set方法中可以完成属性赋值。推荐使用！

我们来实现一下，新建一个项目，叫做Spring-02,完成后的项目结构为：

在这里插入图片描述

首先创建一个Student类

package com.lu.test01;

public class Student {
   
    private String name;
    private int age;

    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;
    }

    @Override
    public String toString() {
   
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

来编写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">

    <!--声明bean-->
    <bean id="myStudent" class="com.lu.test01.Student"></bean>
</beans>

编写测试类：

@Test
public void test01() {
   
    String config = "test01/applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    Student student = (Student) ctx.getBean("myStudent");

    System.out.println("student == " + student);
}

控制台输出：

在这里插入图片描述

我们发现对象创建成功了，但是还没有赋值，现在我们要做的工作就是给属性赋值。

我们来重新编写applicationContext.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">

    <!--声明bean-->
    <!--
        DI:给属性赋值
        简单类型：java中的基本数据类型和String

        1.set注入：spring调用类的set方法，通过set方法完成属性赋值
            简单类型的set注入：
            语法：<bean id="xxx" class="yyyy">
                    <property name="属性名" value="简单类型属性值"/>
                    ....
                </bean>
        -->
    <bean id="myStudent" class="com.lu.test01.Student">
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
    </bean>
</beans>

语法格式在上面已经说明了，我们重新来跑一下测试类：

在这里插入图片描述

这里我们需要说明几点，

  • 第一点是定义的类中属性必须要有对应的set方法，否则会报错

  • 第二点是set方法里面可以随便定义，不一定非得有赋值语句，如果没有赋值语句，就不会赋值，但不会报错

  • 第三点是如果set方法没有对应的属性值，也是可以执行的，只是只会执行该set方法，不会对不存在属性进行赋值

2.5.1.1.1 给非自定义类的属性赋值

上面我们举的例子是给自定义的类的属性进行赋值，那么如何给非自定义的类的属性赋值呢？

我们拿Date类来举一个例子

我们去查看Date类的源代码，发现set方法是下面这一个

在这里插入图片描述

也就是说我们需要给time进行赋值，且time是简单类型

我们再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">

    <!--声明日期类-->
    <bean id="mydate" class="java.util.Date">
        <property name="time" value="2432115451534"></property>
    </bean>
</beans>

编写测试类：

@Test
public void test02() {
   

    String config = "test01/applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    Date date = (Date) ctx.getBean("mydate");
    System.out.println("date == " + date);
}

控制台输出：

在这里插入图片描述

我们看到由于我们自己设置了值，现在的时间到达了2047年

2.5.1.1.2 给引用类型赋值

我们重新创建一个包，包结构如下：

在这里插入图片描述

我们首先定义一个School类

package com.lu.test02;

public class School {
   

    private String name;
    private String address;

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

    public void setAddress(String address) {
   
        this.address = address;
    }

    @Override
    public String toString() {
   
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

再定义一个Student类

package com.lu.test02;

public class Student {
   
    private String name;
    private int age;

    //引用类型
    private School school;

    public Student() {
   
        System.out.println("Student类的无参构造方法执行了....");
    }


    public void setName(String name) {
   
        System.out.println("setName == " + name);
        this.name = name;
    }



    public void setAge(int age) {
   
        System.out.println("setAge == " + age);
        this.age = age;
    }

    public void setSchool(School school) {
   
        System.out.println("setSchool == " + school);
        this.school = school;
    }

    @Override
    public String toString() {
   
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

我们来编写applicationContext.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">

    <!--声明bean-->
    <!--
        DI:给属性赋值
        简单类型：java中的基本数据类型和String

        1.set注入：spring调用类的set方法，通过set方法完成属性赋值
            简单类型的set注入：
            语法：<bean id="xxx" class="yyyy">
                    <property name="属性名" value="简单类型属性值"/>
                    ....
                </bean>

        2.set注入：
            引用类型set注入：
            语法：
                <bean id="xxx" class="yyy">
                    <property name="属性名" ref="bean的id"/>
                    ...
                </bean>
        -->
    <bean id="myStudent" class="com.lu.test02.Student">
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
        <property name="school" ref="mySchool"></property>
    </bean>

    <!--声明school-->
    <bean id="mySchool"  class="com.lu.test02.School">
        <property name="name" value="清华大学"></property>
        <property name="address" value="北京"></property>
    </bean>

</beans>

我们来编写测试类：

@Test
public void test01() {
   
    String config = "test02/applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
    Student student = (Student)ctx.getBean("myStudent");

    System.out.println(student);

}

控制台输出：

在这里插入图片描述

我们可以看到，对于引用类型的赋值，我们必须使用ref来引用

格式为：

<bean id="xxx" class="yyy">
	<property name="属性名" ref="引用类型的bean的id"/>
	...
</bean>
2.5.1.2 构造注入

构造注入：spring调用类中的有参构造方法，在创建对象的同时，给属性赋值。

我们举个例子，首先修改Student类，School类不需要修改

package com.lu.test03;

public class Student {
   
    private String name;
    private int age;

    //引用类型
    private School school;

    public Student() {
   
        System.out.println("Student类的无参构造方法执行了....");
    }

    public Student(String name, int age, School school) {
   
        System.out.println("Student的有参构造方法执行了...");
        this.name = name;
        this.age = age;
        this.school = school;
    }

    @Override
    public String toString() {
   
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

再来修改applicationContext.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">

   <!--
        构造注入：spring调用类的有参构造方法，创建对象同时给属性赋值
        语法：
            <bean id="xxx" class="yyy">
                <constructor-arg>:表示一个构造方法的形参
                标签有属性：name:构造方法形参名
                          index:构造方法的参数位置
                          value:简单类型的形参值
                          ref:引用类型的形参值
    -->
    <bean id="myStudent" class="com.lu.test03.Student">
        <constructor-arg name="name" value="李四"></constructor-arg>
        <constructor-arg name="age" value="25"></constructor-arg>
        <constructor-arg name="school" ref="mySchool"></constructor-arg>
    </bean>

    <!--声明school-->
    <bean id="mySchool"  class="com.lu.test03.School">
        <property name="name" value="清华大学"></property>
        <property name="address" value="北京"></property>
    </bean>

</beans>

我们来编写测试类：

package com.lu;

import com.lu.test03.Student;
import org.junit.Test;
import org.springframework.context.
最低0.47元/天 解锁文章
再让我学一会吧！
关注
  • 43
    点赞
  • 踩
  • 178
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
【Spring】Spring 入门介绍
web15285868498的博客
06-18 569
Spring（Spring Framework） 是一个开源的轻量级框架，是包含了众多工具方法的 IoC 容器。那么什么 是 IoC 容器呢？容器 本身的含义是用来容纳某种物品的装置，而在之前的学习中，我们就应该接触过一些容器了，比如存储数据的容器 List、Map、Set 等等，Web 容器 Tomcat 等等。那么 IoC 是什么呢？IoC（Inversion of Control），译为控制反转，它不是什么技术，而是一种思想。在 Java 开发中，IoC 意味着你将设计好的依赖对象 B 交给容器控制，
Spring新手教程
青玉白露的博客
05-22 580
基于《Spring实战》第五版进行学习 让我们来一起学习Java Spring吧！ Spring基础 介绍 Spring 的核心是一个容器，通常称为 Spring 应用程序上下文，用于创建和管理应用程序组件。**这些组件（或 bean）**在 Spring 应用程序上下文中连接在一起以构成一个完整的应用程序。 将 bean 连接在一起的行为是基于一种称为 依赖注入（DI）的模式。依赖项注入的应用程序不是由组件自身创建和维护它们依赖的其他 bean 的生命周期，而是依赖于单独的实体（容器）来创建和维护所有.
Spring8大模块
SSSSSSch的博客
11-07 601
Spring8大模块
史上最全Spring锦集（学习指南+实战+ 源码解析+架构与设计原理）
最新发布
2401_84048416的博客
04-20 687
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
Spring入门，看这篇就够了
m0_54928777的博客
06-17 3333
一篇对Spring入门案例演示的文章，仅供正在学习Spring的小伙伴们参考哟！
初识 - Spring
chenbaifan的博客
07-06 5527
我们通常所说的 Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架,⽤⼀句话概括 Spring：就跟据字面来理解,装水的瓶子可以叫容器,可以装衣服的衣柜可以叫容器,总之,可以用来容纳某种物品(基本)装置我们都可以叫容器向我们之前所学过的知识: 翻译成中⽂是 “控制反转” 的意思，也就是说 Spring 是⼀个“控制反转”的容器,是 Spring 的核心,贯穿始终.这个 IOC ，对于 Spring框架来说，就是由 Spring 来负责控制对象的生命周期和对象间的关
Spring入门这一篇就够了
3y
03-11 894
前言前面已经学习了Struts2和Hibernate框架了。接下来学习的是Spring框架…本博文主要是引入Spring框架…Spring介绍Spring诞生：侵入式概念...
Spring简易入门
Mart1nn的博客
03-07 258
想直接上手代码的可以先看第二部分。 目录 一、理论基础 二、实战 一、理论基础 Spring是一个轻量级、低侵入性的java ee开源框架。这句话都知道，那么我们先来科普一下。 1、什么是轻量级？ 轻量级框架是指那些不需要依赖容器就能运行的框架，比方说都知道EJB是个重量级框架，需要依赖于JBoss等容器；而Spring，Mybatis等都是不需要依赖容器的轻量级框架。 2、什么是...
Java/spring相关资源，一文带你入门spring的世界，给你讲透核心组件
03-21
Spring框架是Java EE应用开发中最流行的轻量级框架之一，它简化了企业级应用的开发过程，尤其是对于依赖注入（DI）、面向切面编程（AOP）、事务管理等方面有着强大的支持。
一文详解Spring任务执行和调度(小结)
08-25
【Spring任务执行和调度】是Spring框架中处理异步任务和定时任务的重要组成部分。这篇文章将对Spring中的TaskExecutor和TaskScheduler接口进行详细讲解，并通过示例代码帮助理解它们的使用。 **一、TaskExecutor** ...
「深度好文」一文读懂社区类产品设计
02-26
社区产品设计是一个巨大的议题，一个社区如同一个小社会，里面会错综交杂着各种关系和利益链条，而且这个小社会中的关系会随着社区的增大和发展而不断演进变化。在产品设计中，需要充分结合社区所服务的人群，即目标...
从零开始学Spring Boot
05-21
从零开始学Spring Boot,没有积分的可以看博客：http://412887952-qq-com.iteye.com/ 【Spring Boot 系列博客】 0）前言【从零开始学Spring Boot】 : http://412887952-qq-com.iteye.com/blog/2291496 （1）spring boot起步之Hello World【从零开始学Spring Boot】: http://412887952-qq-com.iteye.com/blog/2291500 （2）Spring Boot返回json数据【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2291508 （15）Spring Boot使用Druid和监控配置【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2292362 16）Spring Boot使用Druid（编程注入）【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blogs/2292376 （17）Spring Boot普通类调用bean【从零开始学Spring Boot】： http://412887952-qq-com.iteye.com/blog/2292388 ...... （35）Spring Boot集成Redis实现缓存机制【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2294942 更多查看博客：http://412887952-qq-com.iteye.com/
一文带你搞懂Spring MVC和servlet（面试必备）
12-21
一、Spring MVC与Jsp/Servlet比较1、传统的 Jsp/Servlet 技术体系弊端2、Spring Web MVC 特点3、Spring MVC工作流程二、idea创建servlet项目1、搭建过程2、servlet的工作流程3、servlet的生命周期三、idea创建Spring...
spring语法结构
颜小小的博客
10-31 498
1. SpringMVC调用流程 组件： 1.前端控制器 所有请求的中转站 2.处理器映射器 将用户的请求与执行的业务方法进行映射(绑定) 3.处理器适配器 4.视图解析器 2. @RestController @RestController=@Controller+@ResponseBody @ResponseBody 返回值为String类型则返回字符串本身 返回的是一个对象则返回json串使用 若返回json等内容到页面，则需要加@ResponseBody注解 程序将不会执行视图解析器Interna
Spring核心编程
gcl的博客
12-05 205
Spring
Spring-全面详解（基础知识）
热门推荐
m0_63324772的博客
03-24 2万+
Spring-全面详解（基础知识）入门级 持续更新中 Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
Spring AOP中文教程
01-07 1746
这是在网上发现的一篇关于Spring AOP编程的教程，读完这篇文章后，Spring AOP不再难以理解，因此我把它译成中文，推荐给Spring AOP的初学者。这是译文的链接。 AOP正在成为软件开发的下一个圣杯。使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。 为了理解AOP如何做到这点，考虑一下记日志的工作。日志
Spring入门（1)
想吃一口西多
07-23 1187
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集...
Spring框架的入门
新白的博客
06-26 148
Spring的入门 Spring一、Spring的jar包二、java代码三、 新建log4j四、结果 一、Spring的jar包 链接：https://pan.baidu.com/s/1vnFkEAGHey06edMXeyNyZw 提取码：1dvm 二、java代码 UserDAO.java： package com.lwc.dao; /** * 用户管理DAO层接口 * @author xinbai * */ public interface UserDAO { public.
一文读懂 spring bean 生命周期
10-08
Spring Bean 的生命周期是指在 Spring 容器中创建和管理一个 Bean 的整个过程。对于 singleton bean，它的生命周期可以分为以下几个阶段： 1. 实例化（Instantiation）：在这个阶段，Spring 会根据配置信息实例化一个 Bean 对象。通常情况下，Spring 使用无参构造函数来创建对象。 2. 属性赋值（Populate properties）：在实例化之后，Spring 会通过依赖注入或自动装配的方式将配置的属性值注入到 Bean 中。 3. 初始化（Initialization）：在属性赋值之后，Spring 会调用 Bean 的初始化方法来进行一些特定的初始化操作。可以通过在配置文件中使用 init-method 属性来指定初始化方法。 4. 使用（In use）：在初始化之后，Bean 就可以被使用了，业务逻辑可以对其进行操作。 5. 销毁（Destruction）：当容器关闭或者手动销毁 Bean 时，Spring 会调用 Bean 的销毁方法来进行一些资源释放等清理工作。可以通过在配置文件中使用 destroy-method 属性来指定销毁方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

再让我学一会吧！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值