Spring第一天

已于 2024-03-03 01:09:21 修改
阅读量931 收藏 27
点赞数 31
分类专栏： Spring 文章标签： spring java
于 2024-03-02 21:32:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44478828/article/details/136422641
版权

学习目标

  • 能够说出Spring的体系结构
  • 能够编写IOC入门案例
  • 能够编写DI入门案例
  • 能够配置setter方式注入属性值
  • 能够配置构造方式注入属性值
  • 能够理解什么是自动装配

一、Spring简介

1 Spring课程介绍

问题导入

我们为什么要学习Spring框架？

1.1 为什么要学

  • Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>==90%==

  • 专业角度

    • ==简化开发==，降低企业级开发的复杂性

    • ==框架整合==，高效整合其他技术，提高企业级应用开发与运行效率

1.2 学什么

  • 简化开发

    • ==IOC(反转控制)==

    • ==AOP(面向切面编程)==

      • ==事务处理==

  • 框架整合

    • MyBatis

    • MyBatis-plus

    • Struts

    • Struts2

    • Hibernate

    • ……

1.3 怎么学

  • 学习Spring框架设计思想

  • 学习基础操作，思考操作与思想间的联系

  • 学习案例，熟练应用操作的同时，体会思想

2 初识Spring

问题导入

目前我们使用的是Spring几版本？

2.1 Spring家族

  • 官网：https://spring.io

  • Spring发展到今天已经形成了一种开发的生态圈，Spring提供了若干个项目，每个项目用于完成特定的功能。

2.2 Spring发展史

3 Spring体系结构

问题导入

通过系统架构图，Spring能不能进行数据层开发？Spring能不能进行web层开发？

3.1 Spring Framework系统架构图

  • Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基

3.2 Spring Framework课程学习路线

4 Spring核心概念

问题导入

问题1：目前我们的代码存在什么问题以及怎么解决这些问题？

问题2：请描述什么是IOC，什么是DI？

4.1 目前我们代码存在的问题

  • 代码书写现状

    • 耦合度偏高

  • 解决方案

    • 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

4.2 核心概念

  • ==IOC（Inversion of Control）控制反转==

    使用对象时，由主动new产生对象转换为由==外部==提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“==将new对象的权利交给Spring，我们从Spring中获取对象使用即可==”

  • Spring技术对IoC思想进行了实现

    • Spring提供了一个容器，称为==IOC容器==，用来充当IoC思想中的“外部”

    • IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为==Bean==

  • ==DI（Dependency Injection）依赖注入==

    • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。

  • 目标：充分解耦

    • 使用IoC容器管理bean（IOC)

    • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）

  • 最终效果

    • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

二、IOC和DI入门案例【重点】

1 IOC入门案例【重点】

问题导入

<bean>标签中id属性和class属性的作用是什么？

1.1 门案例思路分析

  1. 管理什么？(Service与Dao)

  2. 如何将被管理的对象告知IOC容器？(配置文件)

  3. 被管理的对象交给IOC容器，如何获取到IoC容器？(接口)

  4. IOC容器得到后，如何从容器中获取bean？(接口方法)

  5. 使用Spring导入哪些坐标？(pom.xml)

1.2 实现步骤

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象 

1.3 实现代码

【第一步】导入Spring坐标

<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

【第二步】定义Spring管理的类（接口）

  • BookDao接口和BookDaoImpl实现类

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象

  • 定义applicationContext.xml配置文件并配置BookServiceImpl

<?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属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"></bean>

</beans>

==注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复==

【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}
1.4 运行结果

2 DI入门案例【重点】

问题导入

<property>标签中name属性和ref属性的作用是什么？

2.1 DI入门案例思路分析

  1. 基于IOC管理bean

  2. Service中使用new形式创建的Dao对象是否保留？(否)

  3. Service中需要的Dao对象如何进入到Service中？(提供方法)

  4. Service与Dao间的关系如何描述？(配置)

2.2 实现步骤

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系 

2.3 实现代码

环境代码：

BookService接口和BookServiceImpl实现类：

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

 【第一步】删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第二步】提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

【第三步】配置service与dao之间的关系

在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标签：表示配置bean
    	id属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
			property标签：表示配置当前bean的属性
        	name属性：表示配置哪一个具体的属性
        	ref属性：表示参照哪一个bean
		-->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>
2.4 图解演示

三、Bean的基础配置

问题导入

问题1：在<bean>标签上如何配置别名？

问题2：Bean的默认作用范围是什么？如何修改？

1 Bean基础配置【重点】

配置说明

2 Bean别名配置

配置说明

代码演示

打印结果

3 Bean作用范围配置【重点】

配置说明

扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、application、 websocket ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。

代码演示

打印结果

最后给大家说明一下：在我们的实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性。

四、Bean的实例化

问题导入

Bean的实例化方式有几种？

1 Bean是如何创建的【理解】

bean本质上就是对象，创建bean使用构造方法完成

2 实例化Bean的三种方式

2.1 构造方法方式【重点】

  • BookDaoImpl实现类

public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}

  • applicationContext.xml配置

<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

  • AppForInstanceBook测试类

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}

  • 运行结果

==注意：无参构造方法如果不存在，将抛出异常BeanCreationException==

2.2 静态工厂方式

  • OrderDao接口和OrderDaoImpl实现类

public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

  • OrderDaoFatory工厂类

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}

  • applicationContext.xml配置

<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

  • AppForInstanceOrder测试类

public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}

  • 运行结果

2.3 实例工厂方式

  • UserDao接口和UserDaoImpl实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

  • UserDaoFactory工厂类

//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

  • applicationContext.xml配置

<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

  • AppForInstanceUser测试类

public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

  • 运行结果

2.4 实现FactoryBean<T>方式【扩展,了解】

  • 定义UserDaoFactoryBean实现FactoryBean<UserDao>

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

  • applicationContext.xml配置

<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。

五、依赖注入(DI配置)

1 依赖注入方式【重点】

问题导入

依赖注入有几种方式？

1.1 依赖注入的两种方式

  • setter注入 简单类型 ==引用类型(很常用)==

  • 构造器注入 简单类型 引用类型

1.2 setter方式注入
问题导入

setter方式注入使用什么子标签？

引用类型

简单类型

1.3 构造方式注入
问题导入

构造方式注入使用什么子标签？

引用类型

简单类型
package cn.itcast.dao.impl;


import cn.itcast.dao.BookDao;

public class BookDaoImpl implements BookDao {
    private int connectionNumber;

    public BookDaoImpl(int connectionNumber) {
        this.connectionNumber = connectionNumber;
    }

    @Override
    public String toString() {
        return "BookDaoImpl{" +
                "connectionNumber=" + connectionNumber +
                '}';
    }

    @Override
    public void save() {
        System.out.println("save dao");
    }

}


  <bean id="bookDao" class="cn.itcast.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNumber" value="1234567890"/>
    </bean>
package cn.itcast;


import cn.itcast.dao.BookDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("springContext.xml");
        BookDao bookDao = (BookDao) context.getBean("bookDao");
        System.out.println(bookDao);
    }
}

 运行结果

BookDaoImpl{connectionNumber=1234567890}

参数适配【了解】

1.4 依赖注入方式选择

  1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现

  2. 可选依赖使用setter注入进行，灵活性强

  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨

  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入

  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入

  6. ==自己开发的模块推荐使用setter注入==

2 依赖自动装配【理解】

问题导入

如何配置按照类型自动装配？

2.1 自动装配概念

  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

  • 自动装配方式 ==按类型（常用）== 按名称 按构造方法 不启用自动装配

2.2 自动装配类型
依赖自动装配

配置中使用bean标签autowire属性设置自动装配的类型

package org.example.dao.impl;

import org.example.dao.BookDao;

public class BookDaoImpl implements BookDao {
 private BookDao bookDao;

 @Override
 public void update() {
     System.out.println("BOOKDAO update");
 }

 public void setBookDao(BookDao bookDao) {
     this.bookDao = bookDao;
 }
}

 看容器里面有没有BookDao类型的bean

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byName"/>

看容器里面有没有bookDao名称的bean

依赖自动装配特征

  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作

  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用

  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用

  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

3 集合注入

3.1 注入数组类型数据
<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

3.2 注入List类型数据
<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>
3.3 注入Set类型数据
<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

3.4 注入Map类型数据
<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>
3.5 注入Properties类型数据
<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签

六、Bean的生命周期【了解】

问题导入

问题1：多例的Bean能够配置并执行销毁的方法？

问题2：如何做才执行Bean销毁的方法？

1 生命周期相关概念介绍

  • 生命周期：从创建到消亡的完整过程

  • bean生命周期：bean从创建到销毁的整体过程

  • bean生命周期控制：在bean创建后到销毁前做一些事情

2 代码演示

2.1 Bean生命周期控制

  • 提供生命周期控制方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

  • applicationContext.xml配置

<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

  • 测试类

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
    }
}
2.2 Bean生命周期控制

  • 实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}
<bean id="bookDao" class="cn.itcast.dao.impl.BookDaoImpl"/>

 

测试类代码同《3.2.1 Bean生命周期控制》中的测试代码

3 Bean销毁时机

  • 容器关闭前触发bean的销毁

  • 关闭容器方式：

    • 手工关闭容器 ConfigurableApplicationContext接口close()操作

    • 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机 ConfigurableApplicationContext接口registerShutdownHook()操作

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        ctx.registerShutdownHook();
        //关闭容器
        //ctx.close();
    }
}

敲代码的翠花
关注
  • 31
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring第一天.pdf
08-25
#### 一、Spring框架简介及官方压缩包目录介绍 - **发明者**：Spring框架的主要发明者为Rod Johnson。 - **轮子理论**：Spring框架推崇“轮子理论”，即避免重复发明已有的组件或功能，而是尽可能地利用现有的成熟...
spring第一天课堂笔记
11-13
5. **方便集成各种优秀框架**：Spring提供了对多个第三方框架（如Struts、Hibernate、Hessian、Quartz等）的直接支持，降低了这些框架的使用门槛。 6. **降低Java EE API的使用难度**：Spring对Java EE API进行了...
springcloud第一天，从面试题开始
你还有好多未完成的梦，你有什么理由停下？
05-28 1万+
springcloud第一天，从面试题开始 1、什么是微服务？ 业界大牛： 马丁·福勒 这样描述微服务： 通常而言，微服务架构是一种架构模式或者说是一种架构风格，它提倡将单一应用程序划分为一组小的服务，每个服务运行在其独立的自己的进程中，服务之间互相协调、互相配合，为用户提供最终价格。服务之间采用轻量级的通信机制互相沟通（通常是基于HTTP的RESTful API）。每个服务都围绕着具体业务进...
【Spring】Spring第一天 - 环境搭建、IoC 详解、DI 详解等
热门推荐
寒泉
01-25 6万+
一.Spring 框架简介及官方压缩包目录 介绍 1.主要发明者:Rod Johnson 2.轮子理论推崇者: 2.1 轮子理论:不用重复发明轮子. 2.2 IT 行业:直接使用写好的代码. 3.Spring 框架宗旨:不重新发明技术,让原有技术使用起来更加方便. 4.Spring 几大核心功能 4.1 IoC/DI 控制反转/依赖注入 4.2 AOP 面向切面编程 4.3 声明式事务. 5.Sp...
学习Spring的第5天
有上进心的阿龙
11-04 1万+
学习Spring的第5天 可以使用动态代理来将日志代码动态的写在核心方法执行的前后。 但是，我们发现，虽然动态代理很强大，但是写起来好难。 当然，这个动态代理技术最大的缺陷就是： 如果目标对象没有实现任何接口 ...
Spring第一天：Spring的概述、SpringIOC入门（XML）、Spring的Bean管理、Spring属性注入
AlbertYang的博客
12-02 4888
以前也学习过Spring框架，不过好久没用，当时学完也没做什么总结，都忘的差不多了，今天再从头开始学习一遍。无论是SSH还是SSM都离不开Spring，所以Spring还是很重要的，对于一个想要从事JavaEE开发的人，一定要好好学习Spring框架。Spring的学习计划如下： 第一天：Spring的概述、SpringIOC入门（XML）、Spring的Bean管理、Spring属性注入 第...
学习Spring的第1天
有上进心的阿龙
11-01 6979
学习Spring的第1天 框架： Mybatis使用来解决和数据库进行交互的。 SpringMVC是用来替代我们写这些复杂的Web逻辑的。 Spring是一个容器框架。 EJB：Enterprise Java Bean 核心关注：IOC和AOP 容器：管理所有的组件； 组件：就是你写的那些类。 DI：Dependence Injection依赖注入。 AOP：Aspect Oriented Programming面向切面编程。 进入官网： https://spring.io/ 学好Spring就是学好I
Spring boot小白第一天 spring概述和简述
LIJiaHui232的博客
01-09 4038
SpringBoot第一天 欢迎使用Markdown编辑器-JHui springboot总结 1.2 编写第一个springboot工程 1.2.1 使用maven工具构建一个maven项目 1.2.2 在pom文件中引入父级依赖(spring boot项目启动时自动配置 pom文件如下) <parent> <groupId>org.springframework.boot</groupId> <artifactId>sp
Spring框架第一天(入门，编写配置文件)
dml111727
11-01 1436
Spring框架第一天Spring框架的学习路线1. Spring第一天：Spring的IOC容器之XML的方式，Spring框架与Web项目整合 2. Spring第二天：Spring的IOC容器之注解的方式，Spring的AOP技术 3. Spring第三天：Spring的事务管理、Spring框架的JDBC模板 4. Spring第四天：SSH三大框架的整合 今天内容概述1. Spring框架
spring cloud第一天——莫名其妙历险记
CW_SZDX的博客
11-08 3550
最近因为之前了解了dubbo,spring cloud的源代码（粗颗粒的了解，嘻嘻~），今天没事，搜搜网上（垃圾）教程，想学着搭建个spring cloud。没料到又开启了自闭的一天（有新手在公司做项目的感觉了，又有那味了），还好我是公费自习。 看的搭建教程是如下（但是他好像也不是原创）： 使用IDEA搭建springcloud微服务（一）----父工程的搭建 使用IDEA搭建springclou...
LocalDate获取每周第一天
weixin_42497271的博客
03-01 2503
获取每周第一天
创建并运行一个 Spring项目
lfm1010123的博客
09-30 5637
Spring 项目的两种实现方式
spring第一天学习
02-15
spring学习第一天讲义
day41_Spring第一天.md
09-02
day41_Spring第一天.md
java重点学习-spring
最新发布
qq_40453972的博客
09-03 649
AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。常见的AOP使用场景记录操作日志、●缓存处理Spring中内置的事务处理什么是AOP面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取公共模块复用，降低耦合你们项目中有没有使用到AOP。
JAVA后端框架【spring】--超详解
2302_77125952的博客
08-29 1070
spring是一个轻量级的ioc和Aop的一站式java开发框架，简化企业级开发轻量级：框架体积小（核心模块）
高级java每日一道面试题-2024年8月28日-框架篇[Spring篇]-Spring 框架是什么?
qq_43071699的博客
08-28 810
1. 定义与起源Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。它由Rod Johnson最早提出，目的是解决企业级应用开发的复杂性，简化Java开发。2. 核心特性控制反转（IoC）：也称为依赖注入（DI），是Spring框架的核心。它将对象的创建和依赖关系的管理交给了容器，降低了代码间的耦合度。面向切面编程（AOP）：Spring提供了丰富的AOP支持，允许开发者将横切关注点（如日志、事务管理等）从业务逻辑中分离出来，形成可重用的功能组件。
spring security 相关过滤器
冬阳
08-31 764
Spring Security 提供了 30 多个过滤器。默认情况下Spring Boot 在对 SpringSecurity 进入自动化配置时，会创建一个名为 SpringSecurityFilerChain 的过滤器，并注入到Spring容器中，这个过滤器将负责所有的安全管理，包括用户认证、授权、重定向到登录页面等。
"Spring第02天1：AOP概述及实现原理
Spring的AOP（Aspect Oriented Programming）是一种通过预编译方式和运行期动态代理实现程序功能的统一维护的技术。它是面向对象编程（OOP）的延续，也是软件开发中的热点之一，同时也是Spring框架中的重要内容，也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

敲代码的翠花

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

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

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

打赏作者

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

抵扣说明：

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

余额充值