Spring框架基本理解(1)

最新推荐文章于 2024-07-24 15:40:36 发布
最新推荐文章于 2024-07-24 15:40:36 发布
阅读量29 收藏
点赞数 2
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51464838/article/details/132397645
版权

Spring框架是一款轻量级的开发框架，有两大核心思想：IOC(控制反转)和AOP(面向切面编程)。目的：为了符合企业级标准：高内聚、低耦合，且简化第三方JavaEE中间件技术的使用。Spring框架包括：IOC容器、Validation数据校验、AOP面向切面编程、Transcations事务管理、Spring JDBC、Spring MVC框架、以及各类第三方JavaEE中间件技术集成。

一、基本概念

1、Bean

代表被IOC容器管理的对象(就是类)，通过配置文件告诉IOC容器帮助我们管理哪些bean对象。

2、Spring IOC的理解

IOC(控制反转)是Spring两大核心思想之一，作用：解决业务逻辑和其他各层之间松耦合问题。区别于传统意义上，通过new的方式创建，而是将创建对象的过程交给Spring进行管理。Spring框架使用配置文件的方式，创建bean对象并管理各个bean之间的依赖关系，最终实现解耦。

3、Spring IOC容器的理解

IOC容器其实就是一个Map集合，key是每一个bean对象的ID，value是bean对象本身，默认使用单例的方式将bean存储在Map中；使用集合存储BeanDefinition对象，该对象的封装了Spring对一个Bean所有的配置信息；IOC容器属于Spring core模块，用来创建和管理bean，IOC容器通过配置文件中配置的数据，对各个bean对象进行实例化，并根据bean对象之间的依赖关系完成bean之间的注入。

4、Spring DI的理解

DI(依赖注入)，在容器创建好对象后，处理各个对象之间的依赖关系，在IOC容器运行时，给当前对象注入它所需要的另一个对象。例如：控制层在运行时可能需要业务层的支持，就不再像传统意义上在控制层new一个业务层对象，而是在配置文件中给控制层注入一个它所需要的业务层对象，实现控制层和业务层之间解耦。

二、Spring快速入门(创建Student对象)

1、创建Spring项目，在pom.xml中加入Spring依赖。

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.26</version>
        </dependency>

2、创建Student类。

public class Student {
}

3、在resources目录下创建配置文件。

所有的配置标签写在<beans></beans>这一对父标签中。

子标签为<bean></bean>,属性有：

id：唯一标识

class：类的完全限定名称(注入的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">

    <!--注入Student类-->
    <bean id="student" class="spring.ioc.popj.Student"></bean>

</beans>

4、在测试方法中创建出Student对象

容器对象有2个：BeanFactory(父接口)，ApplicationContext(子接口)

容器对象的实现类有3个：

ClassPathXmlApplicationContext==>通过文件的相对路径获取核心对象(实现类)

FileSystemXmlApplicationContext==>通过文件的绝对路径获取核心对象(实现类)

AnnotationConfigApplicationContext==>通过加载配置类获取核心对象(实现类)

public class Test01 {
    public static void main(String[] args) {
        //1.加载spring主配置文件获取容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.向spring容器获取student实例
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student);
    }
}

三、Spring DI(依赖注入)的实现方式

1、set注入：通过set方法维护对象之间的依赖关系。

注入的数据类型为：注入对象。

例：三层之间的调用

控制层：

public class IUserControllerImpl implements IUserController{
    //定义业务层对象
    private IUserService service;
    //setter()
    public void setService(IUserService service) {
        this.service = service;
    }

    @Override
    public void save() {
        System.out.println("---controller控制层---");
        //调业务层的save()
        service.save();
    }
}

业务层：

public class IUserServiceImpl implements IUserService{
    //定义数据访问层对象
    private IUserDao dao;
    //setter()
    public void setDao(IUserDao dao) {
        this.dao = dao;
    }

    @Override
    public void save() {
        System.out.println("---service业务层---");
        //调数据访问层的save()
        dao.save();
    }
}

数据访问层：

public class IUserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("---dao层数据访问---");
    }
}

配置文件：

在bean标签内部开启配置，

        配置位置：<bean>此位置</bean>

        配置语法：<property 属性名="属性值"></property>

        配置属性：name：属性名称，value：属性值，ref：属性值的引用。

<?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">
    <!--  注入方式:set注入对象   -->

    <!--  注入IUserControllerImpl  -->
    <bean id="controllerImpl" class="IUserControllerImpl">
        <property name="service" ref="serviceImpl"></property>
    </bean>

    <!-- 注入IUserServiceImpl   -->
    <bean id="serviceImpl" class="IUserServiceImpl">
        <property name="dao" ref="daoImpl"></property>
    </bean>

    <!-- 注入IUserDaoImpl   -->
    <bean id="daoImpl" class="IUserDaoImpl"></bean>
</beans>

测试类：

public class Test01 {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
        //set注入对象
        IUserController iUserController = (IUserController) beanFactory.getBean("controllerImpl");
        //控制层调save()方法
        iUserController.save();
    }
}

注入的数据类型为：注入基本数据类型和String。

定义Student类：不通过有参构造方法给属性赋值，而是在IOC容器创建对象时通过set()给属性赋值。

public class Student {
    //成员变量
    private String name;
    private String hooby;
    private int age;
    
    //setter()
    public void setName(String name) {
        this.name = name;
    }

    public void setHooby(String hooby) {
        this.hooby = hooby;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", hooby='" + hooby + '\'' +
                ", age=" + age +
                '}';
    }
}

配置文件：

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

    <!-- set注入基本数据类型和String   -->
    <bean id="student" class="spring.ioc.popj.Student">
        <property name="name" value="光头强"></property>
        <property name="hooby" value="砍树"></property>
        <property name="age" value="25"></property>
    </bean>
</beans>

注入复杂类型(list、array、set、map、properties)。

Teacher类：属性类型类复杂类型

public class Teacher {
    //List
    private List list;
    //Set
    private Set set;
    //Map
    private Map map;
    //array
    private String[] array;
    //properties
    private Properties properties;

    public void setList(List list) {
        this.list = list;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", array=" + Arrays.toString(array) +
                ", properties=" + properties +
                '}';
    }
}

配置文件：

<?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">
    
    <!-- set注入复杂类型(list,set,map,array,properties)   -->
    <bean id="teacher" class="spring.ioc.popj.Teacher">

    <!--   list类型     -->
        <property name="list">
            <list>
                <value>上课</value>
                <value>备课</value>
                <value>批作业</value>
            </list>
        </property>

    <!--  set类型      -->
        <property name="set">
            <set>
                <value>健身</value>
                <value>跑步</value>
                <value>散步</value>
            </set>
        </property>

    <!--  array类型      -->
        <property name="array">
            <array>
                <value>光头强</value>
                <value>熊大</value>
                <value>熊二</value>
            </array>
        </property>

    <!--   map类型：键值对     -->
        <property name="map">
            <map>
                <entry key="千里送鹅毛" value="礼轻情意重"></entry>
                <entry key="小葱拌豆腐" value="一清二白"></entry>
                <entry key="及时雨" value="宋江"></entry>
            </map>
        </property>

    <!--  properties类型      -->
        <property name="properties">
            <props>
                <prop key="自助">12</prop>
                <prop key="面条">13</prop>
                <prop key="肉夹馍">14</prop>
            </props>
        </property>
    </bean>
</beans>
2、构造注入：通过构造方法维护对象之间的依赖关系。

注入的数据类型为：注入对象。l

例：三层之间的调用

控制层：

public class IUserControllerImpl implements IUserController{
    
    //定义业务层对象
    private IUserService service;

    //有参构造方法(传入参数：IUserService)
    public IUserControllerImpl(IUserService service) {
        this.service = service;
    }

    //无参构造方法
    public IUserControllerImpl() {
    }

    @Override
    public void save() {
        System.out.println("---controller控制层---");
        //调业务层save()
        service.save();
    }
}

业务层：

public class IUserServiceImpl implements IUserService{
    //定义数据访问层对象
    private IUserDao dao;

    //无参构造方法
    public IUserServiceImpl() {
    }
    //有参构造方法
    public IUserServiceImpl(IUserDao dao) {
        this.dao = dao;
    }

    @Override
    public void save() {
        System.out.println("---service业务层---");
        //调数据访问层save()
        dao.save();
    }
}

数据访问层：

public class IUserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("---dao层数据访问---");
    }
}

配置文件：

在bean标签内部开启配置

        配置位置：<bean>此位置</bean>

        配置语法：< constructor-arg 属性名="属性值"></ constructor-arg>

        配置属性：name：构造方法中参数名称，value：属性值，ref：属性值的引用，index：构造                            方法中参数下标，type：构造方法中参数类型。

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

    <!--构造注入:注入对象    -->
    <!-- name:构造方法中参数名称  ref：属性值的引用   -->
    <bean id="controllerImpl" class="spring.ioc.controller.IUserControllerImpl">
        <constructor-arg name="service" ref="serviceImpl"></constructor-arg>
    </bean>
    <bean id="serviceImpl" class="spring.ioc.service.IUserServiceImpl">
        <constructor-arg name="dao" ref="daoImpl"></constructor-arg>
    </bean>
    <bean id="daoImpl" class="spring.ioc.dao.IUserDaoImpl"></bean>

</beans>

注入的数据类型为：注入基本数据类型和String。

Student类：通过有参构造方法在创建对象时给定属性值。

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

    //有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

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

配置文件：

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

    <!-- 构造注入Student类，注入基本数据类型和String:使用构造方法的参数名称   -->
    <bean id="student1" class="spring.ioc.popj.Student">
        <constructor-arg value="光头强" name="name"></constructor-arg>
        <constructor-arg value="20" name="age"></constructor-arg>
    </bean>
    <!-- 构造注入Student类，注入基本数据类型和String:使用构造方法的参数下标   -->
    <bean id="student2" class="spring.ioc.popj.Student">
        <constructor-arg value="熊大" index="0"></constructor-arg>
        <constructor-arg value="18" index="1"></constructor-arg>
    </bean>
    <!-- 构造注入Student类，注入基本数据类型和String:使用构造方法的参数类型   -->
    <bean id="student3" class="spring.ioc.popj.Student">
        <constructor-arg value="熊二" type="java.lang.String"></constructor-arg>
        <constructor-arg value="16" type="int"></constructor-arg>
    </bean>

</beans>

构造注入不支持数据类型为复杂类型。

3、属性注入(不推荐)：使用成员变量注入bean，原因：使用私有的成员变量，依靠反射实现，破坏封装，只能依靠IOC容器实现注入，不严谨。

四、Bean的实例化

1、通过类的无参构造方法实例化(默认方式)

例：创建Teacher对象

Teacher类：

通过类的无参构造方法实例化（默认）
public class Teacher {
    public Teacher() {
        System.out.println("---Teacher类的无参构造方法---");
    }
}

配置文件：

<?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="teacher" class="spring.ioc.popj.Teacher"></bean>
</beans>
2、通过指定工厂创建对象

Teacher类：

public class Teacher{
}

Factory类：

public class BeansFactory {
    //通过工厂创建Teacher对象
    public Teacher createStu() {
        System.out.println("===通过工厂创建对象===");
        return new Teacher();
    }
}

配置文件：

<?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">
       
        <!--  通过指定工厂创建对象      -->
        <!--factory-bean:指定工厂类，factory-method:指定工厂类中创建对象的方法-->
        <bean id="teacher" class="spring.ioc.popj.Teacher" factory-bean="factory" factory-method="createStu"></bean>
        <bean id="factory" class="spring.ioc.factory.BeasFactory"></bean>

</beans>
3、通过指定静态工厂创建对象

 Teacher类：

public class Teacher{
}

Factory类：

public class StaticBeansFactory {
    //通过工厂创建Teacher对象
    public static Teacher createStu() {
        System.out.println("===通过静态工厂创建对象===");
        return new Teacher();
    }
}

配置文件：

<?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="teacher" class="spring.ioc.factory.StaticBeasFactory" factory-method="createStu"></bean>
</beans>

五、Bean的作用域

语法：scope="属性"

singleton(单例)：Spring只会为该bean对象创建唯一实例，Spring中的bean默认都是单例。

prototype(多例)：每次获取bean，Spring都会创建一个新的bean实例。

request：每一次http请求，Spring都会创建一个新的实例。

session：不同的http会话，Spring都会创建一个新的实例。

request和session需要有Web环境。

<?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="teacher" class="spring.ioc.popj.Teacher" scope="singleton"></bean>

        <!--  多例，性能差，安全性好      -->
        <bean id="teacher" class="spring.ioc.popj.Teacher" scope="prototype"></bean>
</beans>

Spring的另一大核心思想Spring AOP部分及Bean的生命周期请看下一遍文章。

猿究院-小刘同学
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring框架搭建
09-13
Spring框架是中国著名的开源Java企业级应用开发框架，由Rod Johnson在其著作《Expert One-on-One J2EE Design and Development》中...对于初学者来说，这是一个很好的实践平台，有助于深入理解Spring框架的使用和原理。
JAVA学习之一步步搭建spring框架
08-29
【标题】：深入理解Spring框架搭建过程 【摘要】：本文详细阐述了如何逐步搭建Java中的Spring框架，从创建Maven工程开始，直至添加必要的Spring依赖。通过此过程，开发者可以更好地理解Spring框架的构建基础。 ...
Spring框架(浅谈)
weixin_62460384的博客
12-01 1085
1.浅谈IOC与DI 2.理解AOP面向切面编程的思想 3.Spring中的注解
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
【Java】Spring框架介绍
double222222的博客
01-30 1267
Spring框架以其灵活性、可扩展性和简化开发的理念在Java开发领域占据着重要地位。通过深入理解Spring的核心理念和组件，以及在实际应用中的最佳实践，开发者可以更好地利用这一强大的框架，提高应用程序的质量和可维护性。希望本文能够帮助读者更好地掌握和运用Spring框架。
关于对Spring框架的详解
S_yyuan的博客
02-27 1285
Spring框架的详细理解
Spring框架详解
热门推荐
m0_63324772的博客
04-12 5万+
Spring框架详解（五万字）入门级 简介Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
SpringCloud基本框架+完整示例工程.rar
01-04
本压缩包文件“SpringCloud基本框架+完整示例工程”提供了全面的学习资源，帮助开发者快速理解和上手SpringCloud。 1. **SpringCloud Eureka**：作为服务发现组件，Eureka实现了服务注册与发现的功能。服务提供者在...
ssm框架最基本源码
01-29
**Spring框架** 是一个全面的企业级应用开发框架，核心特性是依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）。依赖注入允许开发者在运行时通过配置文件或注解来管理对象...
深入解析Java Spring框架
03-04
本文将全方位探讨Java Spring框架，包括基本介绍、个人心得、实际项目经验分享以及相关深度练习。 一、Java Spring框架介绍 1.1 概述 Java Spring框架是一个综合性的开发框架，旨在简化企业级应用的开发过程。它...
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 374
zookeeper安装并成功运行。
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 319
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
Spring Security学习笔记（二）Spring Security认证和鉴权
最新发布
飞！！！的博客
07-24 665
用户认证的基础Filter，只有UsernamePasswordAuthenticationFilter这一个实现类。...//主要方法//先校验请求url与表单校验提交的url是否一致，不一致执行下一个Filter//一致的话就执行认证逻辑，一般默认的表单提交url是"/login"if (!} else {try {//实现类执行具体的认证逻辑return;//由子类实现具体的验证逻辑...
springboot之自动装配
weixin_50153914的博客
07-23 515
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Springboot @Validate @Valid 基于复杂嵌套对象的参数校验示例
nancheng_wx的博客
07-23 407
【代码】Springboot @Validate @Valid 基于复杂嵌套对象的参数校验示例。
分享一个Springer模板关于论文作者和单位信息的修改范例，以及Applied Intelligence期刊latex模板的下载链接
qq_66536007的博客
07-23 914
分享一个Springer模板关于论文作者和单位信息的修改范例，以及Applied Intelligence期刊latex模板的下载链接
Spring AI (五) Message 消息
yuanchun的知识整理
07-24 1107
上下文 角色设置
SpringSecurity如何正确的设置白名单
waooi的博客
07-23 431
在SpringSecurity中,往往需要对部分接口白名单访问,而大部分在使用Security中就有一个误区,那就是免鉴权访问和白名单的区别。大部分的Security文章包括官方文档给出免鉴权访问都是使用去对相应路径进行免鉴权访问,但实际上这仅仅只表示该资源不需要相应的权限访问，但是用户还需要认证.也就是Securityd的认证/授权两个概念.
SpringBoot开发中如何缓存数据, 减少数据库的访问频率？
weixin_70289842的博客
07-23 349
方法一：在不同环境的配置文件中如application-dev.yml、application-test.yml、application-prod.yml，修改 spring.cache.type = none;spring:cache:type: none方法二：自定义配置## 开启数据缓存caching:缓存配置文件//配置文件读取是否启用此配置二：simpleCacheManage基于实现，不依赖其他库，如果增加了注解，默认开启缓存，可以通过设置限制缓存列表1.设置缓存列表。
深入理解Spring框架：从入门到精通
在Spring框架中，许多核心组件和服务都是通过接口来实现的，如ApplicationContext接口提供了容器的基本功能，BeanFactory接口负责bean的创建和管理。 Spring框架的全面性和灵活性使得它在现代Java开发中不可或缺。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值