Spring框架介绍及其基本使用

最新推荐文章于 2024-07-15 15:14:58 发布
最新推荐文章于 2024-07-15 15:14:58 发布
阅读量537 收藏
点赞数
分类专栏： 原理解析 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengyi1108/article/details/116561636
版权

Spring

Spring框架概述

  • Spring是轻量级的开源的JavaEE框架。
  • Spring可以解决企业应用开的复杂性。
  • Spring的核心：IOC和AOP。
    • IOC：控制反转，把创建对象的过程交给Spring进行管理。
    • AOP：面向切面，不修改源码的情况下，进行功能的添加和增强。
  • Spring特点
    • 方便解耦，简化开发。
    • AOP编程的支持。
    • 方便程序的测试（整合Junit）。
    • 方便和其他框架的整合。
    • 方便进行事务操作。
    • 降低API开发难度

spring5

IOC容器

什么是IOC

  • 控制反转，把对象的创建和对象之间的调用过程，交给Spring进行管理。使用IOC的目的，为了耦合度降低。

IOC底层原理

  • xml解析、工厂模式、反射。

IOC接口

  • IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
  • Spring 提供IOC容易的两种方式（两个接口）：

    • BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员进行使用。加载配置文件的时候不会创建对象，在获取（使用）对象的时候采取创建对象。下图的子接口可以包含一些相关的扩展功能BeanFactory实现类

    • ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。加载配置文件的时候就会把在配置文件中的对象进行创建。这种方式更常用，因为把耗时的资源都放在项目（服务器）启动的时候加载更好。 下图的两种方法分别是读取系统文件和项目资源文件ApplicationContext的实现接口

IOC操作

Bean管理

bean管理是指两个操作：spring创建对象和spring注入属性
Bean 管理操作有两种方式

  • 基于XML配置文件方式实现
    在这里插入图片描述
  • 创建对象，在spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象创建。
    • id 属性 给对象唯一取别名（标识）
    • class属性 类全路径（包类路径）
    • 创建对象的时候，默认也是执行无参数构造方法完成对象创建，若用有参构造将无参构造顶掉，会报错。
基于xml方式创建对象和注入属性
  • DI 依赖注入，就是注入属性。
    • set方法注入
    • 有参构造注入
    • p名称空间注入（了解）
  • 基于xml注入其他类型属性
    • 字面量
      • null值，使用null标签
      • 属性值包含特殊符号
        • 转义 &lt，&gt等
        • 把特殊内容写到CDATA结构中，添加value标签，标签内容为：<![CDATA[<<南京>>]]>
    • 外部Bean
      • 创建Service类和Dao类
      • 在Service中调用Dao,在xml文件中配置，id对应ref，name对应注入属性的名称
        <!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
   <!--注入userDao对象
       name属性：类里面属性名称
       ref属性：创建userDao对象bean标签id值
   -->
   <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
    • 内部Bean和级联赋值
    <!--内部bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="com.atguigu.spring5.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>
    • 注入数组、List、Map、Set类型属性
    <!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>java课程</value>
            <value>数据库课程</value>
        </array>
    </property>
    <!--list类型属性注入-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>小三</value>
        </list>
    </property>
    <!--map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
    <!--注入list集合类型，值是对象-->
    <property name="courseList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="MyBatis框架"></property>
</bean>
    • 把集合注入部分提取出来
      • 在spring配置文件中引入名称空间
      • 使用引入的标签完成注入提取
      <?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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!--1 提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>

    <!--2 提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>
FactoryBean

Spring中有两种类型的Bean，一种是Bean，另外一种是Bean（FactoryBean）

  • 普通Bean：在配置文件中，定义Bean的类型就是返回类型
  • 工厂Bean：在配置文件中，定义的Bean类型可以和返回的类型不一样
    • 创建一个类，让这个类作为工厂Bean，实现FactoryBean
    • 实现接口里面的方法，在实现的方法中定义返回的Bean类型
Bean的作用域

在spring里面，设置创建Bean实例是单实例还是多实例
默认情况下，Bean是单实例对象

  • 如何设置单实例还是多实例
    • xml配置文件中scope的值，singleton（默认）：表示是单实例对象。prototype：标识多实例对象。request（一次请求）：每次创建对象会放到request中 session（一次会话）：每次创建对象会放到session中。
    • singleton和prototype的区别：singleton在加载spring配置文件的时候就会创建单实例对象。prototype不是在加载spring配置文件的时候创建对象，是在调用getBean方法的时候创建多实例对象。
Bean生命周期
从对象创建到对象销毁的过程。
  • 通过构造器创建bean实例（无参构造）
  • 为bean的属性设置值和对其他bean引用（调用set方法）
  • 调用bean的初始化的方法（需要进行配置）在xml中添加init-method属性
  • bean可以使用了（对象获取到了）
  • 当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）在xml中添加destroyMethod属性
加上bean的后置处理器。

创建类，实现接口BeanPostProcessor，创建后置处理器，并在xml中配置

  • 通过构造器创建bean实例（无参构造）
  • 为bean的属性设置值和对其他bean引用（调用set方法）
  • 把bean实例传递bean后置处理器的方法
  • 调用bean的初始化的方法（需要进行配置）
  • 把bean实例传递bean后置处理器的方法
  • bean可以使用了（对象获取到了）
  • 当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
Bean自动装配

根据指定的装配规则（属性名称或者属性类型），spring自动将匹配的属性值进行注入。
自动装配

  • 通过xml文件中autowire的属性，byName根据属性名称注入，注入值bean的id值和类属性名称一样。byType根据属性类型注入
外部属性文件
  • 直接配置数据库信息
    • 配置德鲁伊连接池
    • 引入德鲁伊连接池依赖jar包
    <!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>
  • 引入外部属性文件配置数据库连接池
    • 创建外部属性文件，properties格式文件
      在这里插入图片描述
    • 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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

</beans>
基于注解方式实现对象创建和注入属性
什么是注解
  • 注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）
  • 使用注解，可以作用在类上，方法上，属性上。
  • 使用注解目的：简化xml配置，简化开发
Spring针对Bean管理中创建对象提供的注解

一下四个注解功能是一样的，都可以用来创建bean实例

  • @Component
  • @Service
  • @Controller
  • @Repository
基于注解方式实现对象创建
  • 引入aop依赖
  • 开启组件扫描
    • 引入xml命名空间context
    <!-- 开启组件扫描
	1.如果扫描多个包，可以使用，隔开
	2.一般扫描包的上层目录
-->
<context:component-scan base-package="xxxx.xxxx"></context:compoent-scan>
    • 在xml配置中加上use-default-filters并且值等于false时，就不扫描所有注解，只扫描配置的注解
    • 使用< context:exclude-filter >标签时，设置哪些内容不扫描
基于注解方式实现属性注入
  • @AutoWired：根据属性类型进行自动装配
    • 创建service和dao对象，在两个类中添加创建对象注解
    • 在service注入dao对象 ，在service类上添加dao类型的属性，在属性上添加@AutoWired注解
  • @Qualifier：根据属性名称进行注入
    • @Qualifier要和@Autowired注解一起使用
  • @Resource：可以根据类型注入，也可以根据名称注入
  • @Value ：注入普通属性
完全注解开发
  • 创建配置类：加上@Configuration 指定该类为配置类和@ComonentScan(basePackage = “”)注解指定扫描包
  • 使用：生成AnnotationConfigApplicationContext(xxxConfig.class)对象去使用。

AOP

什么是AOP

面向切面编程（面向方面编程）Aspect Oriented Programming。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
通俗描述：不通过修改源代码方式，在主干功能里面添加新的功能

AOP底层原理

  • AOP底层使用动态代理来增强功能
    • 有接口，使用JDK动态代理
      创建接口实现类的代理对象，通过代理对象增强方法。
    • 无接口，使用CGLIB动态代理
      创建当前类子类的代理对象
JDK动态代理

使用Proxy类里面的方法创建代理对象，方法有三个参数：
1、类加载器
2、增强方法所在的类，这个类的实现接口，支持多个接口
3、实现这个接口InvocationHandler，创建代理对象，写增强的部分
编写JDK动态代理代码步骤

术语
  • 连接点：类里面哪些方法可以被增强，这些方法成为连接点
  • 切入点：事迹被真正增强的方法，成为切入点
  • 通知（增强）：
    • 实际增强的逻辑部分成为通知
    • 通知有多种类型
      • 前置通知
      • 后置通知
      • 环绕通知
      • 异常通知
      • 最终通知
  • 切面：把通知应用到切入点过程

AOP操作

  • Spring框架一般都是基于AspectJ实现AOP操作
    AspectJ不是Spring组成部分，独立AOP框架，一般吧AspectJ和Spring框架一起使用，进行AOP操作
  • 基于AspectJ实现AOP操作
    • 基于xml配置文件实现
    • 居于注解方式实现（使用）
  • 在项目工程里面引入AOP相关依赖
  • 切入点表达式
    • 切入点表达式作用：知道对哪个类里面的哪个方法进行增强
    • 语法结构：execution（[权限修饰符][返回类型][类全路径]方法名称）
AspectJ注解
  • 创建类，在类里面定义方法
  • 创建增强类，编写增强逻辑
    • 在增强类里面，创建方法，让不同的方法代表不同通知类型
  • 进行通知配置
    • 在spring配置文件中，开启注解扫描
    • 使用注解创建对象
    • 在增强类上面添加注解@Aspect
    • 在spirng配置文件中开启生成代理对象
@Component
@Aspect
@Order(1)
public class PersonProxy {
    //后置通知（返回通知）
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("Person Before.........");
    }
}

//相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo() {

    }
xml配置文件
  • 创建两个类，增强类和被增强类，创建方法
  • 在spring配置文件中创建两个类对象
<!--创建对象-->
    <bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
  • 在spring配置文件中配置切入点
<!--配置aop增强-->
   <aop:config>
       <!--切入点-->
       <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
       <!--配置切面-->
       <aop:aspect ref="bookProxy">
           <!--增强作用在具体的方法上-->
           <aop:before method="before" pointcut-ref="p"/>
       </aop:aspect>
   </aop:config>
完全注解开发

生成config类

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

JdbcTemplate

什么是JdbcTemplate

  • spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库的操作

JdbcTemplate使用

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

    <!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

事务

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。

  • 原子性（atomicity）：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
  • 一致性（consistency）：在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。
  • 隔离性（isolation）：隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行 相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆， 必须串行化或序列化请 求，使得在同一时间仅有一个请求用于同一数据。
  • 持久性（durability）：在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。

事务操作（编程式事务管理）

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    public void accountMoney() {
//        try {
            //第一步 开启事务

            //第二步 进行业务操作
            //lucy少100
            userDao.reduceMoney();

            //模拟异常
            int i = 10/0;

            //mary多100
            userDao.addMoney();

            //第三步 没有发生异常，提交事务
//        }catch(Exception e) {
            //第四步 出现异常，事务回滚
//        }
    }
}

事务操作（spring声明式事务管理）

有两种方式：基于注解方式实现和基于xml配置文件实现

基于注解方式实现
  • 在spring配置文件配置事务管理器
<!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
  • 在spring配置文件中，开始事务注解
    • 引入名称空间tx
    • 开启事务注解
<!--开启事务注解-->
  <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
  • 在业务层或者业务方法加**@Transactional**注解（不同位置的作用域不同）
@Transactional说明
  • propagation:事务传播行为
    • 多事务方法直接进行调用，这个过程中事务时如何进行管理的
      • 事务方法：对数据库表数据进行变化的操作
    • REQUIRED：如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己事务内运行
    • REQUIRED_NEW：当前的方式必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起
  • isolation：事务隔离级别
    • 事务有特性成为隔离性：多事务操作之间不会产生影响，不考虑隔离性会产生很多问题
      • 脏读：一个未提交事务读取到另一个未提交事务的数据
        无论是脏写还是脏读，都是因为一个事务去更新或者查询了另外一个还没提交的事务更新过的数据。因为另外一个事务还没提交，所以它随时可能会回滚，那么必然导致你更新的数据就没了，或者你之前查询到的数据就没了，这就是脏写和脏读两种场景。
      • 不可重复读：一个未提交事务读取到另一个提交事务修改数据
      • 虚（幻）读：一个未提交事务读取到另一个提交事务添加数据
    • 通过设置隔离性，来解决读问题
      -
  • timeout：超时时间：事务需要在一点时间提交，若不提交则回滚。默认值为-1，设置时间以秒为单位。
  • readOnly：是否只读。有true或者false。
  • rollbackFor：回滚
    • 设置出现那些异常进行事务回滚
  • noRollbackFor：不会滚
    • 设置出现哪些异常不进行回滚
FengYi1108
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 框架简述 (二)
kaema的博客
12-04 633
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Spring Boot 框架介绍和使用
乐百川
03-17 3万+
本文参考自Spring Boot文档。Spring Boot 简介Spring框架功能很强大，但是就算是一个很简单的项目，我们也要配置很多东西。因此就有了Spring Boot框架，它的作用很简单，就是帮我们自动配置。Spring Boot框架的核心就是自动配置，只要存在相应的jar包，Spring就帮我们自动配置。如果默认配置不能满足需求，我们还可以替换掉自动配置类，使用我们自己的配置。另外，Sp
Spring简述二
weixin_44836685的博客
08-10 460
帆帆帆帆
Spring框架的使用
qq_41151938的博客
07-01 651
第一章：Spring概述 1. Spring全家桶： Spring、Spring MVC、Spring Boot、Spring Cloud 2. Spring： 出现在2002年左右，解决企业开发的难度，减轻对模块之间的管理，类和类之间的关系 Spring核心技术ioc，aop。能实现模块之间、类之间的解耦合 3. 依赖： 类A中使用类B的属性或者方法，叫做类A依赖类B 4. 特点 1）轻量 2）针对接口编程，解耦合 3）AOP编程的支持 4）方便集成各种优秀框架 5. 框架怎么学？ 框架是一个软件，其他人
Spring框架详解介绍-基本使用方法
ForFuture
04-28 3558
1.Spring框架—控制反转（IOC）2.Spring框架—面向切面编程（AOP）3.Spring 内置的JdbcTemplate（Spring-JDBC）Spring框架—控制反转（IOC）1 Spring框架概述1.1 什么是SpringSpring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-...
Spring 框架（Spring Framework）使用详解
墨鸦的博客
08-09 1万+
Spring 框架（Spring Framework）使用详解
Spring框架的基本使用与标签
gongwenxi的博客
07-16 598
Spring框架的基本使用与标签 框架的概念 (一)从现实生活的角度来看: 框架，就好像是 “风筝”骨架。 如果我给你一个“风筝”的骨架，你只需要去往这个“风筝骨架”上，贴上一层纸。一个现成的风筝就做好啦~~ 如果没有“风筝的骨架”，那你需要，自己去找“竹子”“木材”“铁丝”等等东西，然后还要“自己手工”的做出一个“风筝骨架”来。。。呵呵，想一想，如果你做100个风筝的话。。。估计就要把人给“累死”啦。。。 (二)从技术角度来看 框架就是半个做好的程序。如果我们要编写程序的话，只需要花费 一半的时间精力，就
Spring框架介绍的外文翻译参考
09-11
Spring框架是Java开发领域中的一款流行开源应用框架，它针对本书中提到的许多问题提供了解决方案。本章将介绍Spring的基本概念，并深入讨论其核心的“bean工厂”轻量级控制反转（IoC）容器。 Spring使得实现轻量级...
JAVA学习之一步步搭建spring框架
08-29
在Java开发中，Spring框架是一个广泛使用的轻量级框架，它提供了强大的依赖注入（DI）和面向切面编程（AOP）功能，简化了企业级应用的开发。本文将逐步讲解如何在Eclipse环境下搭建Spring框架，以便于理解其工作原理...
Spring框架所需基本jar包
12-16
下面将详细阐述这些jar包的作用及其在Spring框架中的重要性。 1. **Spring Core Container**： - `spring-core.jar`: 核心模块，提供了IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖...
传智播客 spring框架2016版资料
04-12
通过传智播客的Spring框架2016版课程，学习者可以深入理解Spring的基本原理和实践应用，为成为一名合格的Java开发人员奠定坚实的基础。在实际学习过程中，应结合PPT和笔记，逐步掌握每个知识点，并通过实际项目练习...
Java Spring 框架搭建步骤
09-06
Spring框架是Java企业级应用开发中的核心框架，它提供了模块化的组件，简化了应用程序的构建和维护。本指南将详细介绍如何一步步搭建一个基于Spring的项目环境。 1. **安装Java开发工具(JDK)** - 首先，确保你的...
spring框架阶段总结
hzy0604的博客
10-17 394
框架阶段总结
Spring框架的基本使用
molu1991的博客
05-15 1752
简要说明： Spring框架：它是一个容器.它是整合其它框架的框架。 Spring框架特点： 轻量级 ：由20多个模块构成并且体积很小 面向接口编程：使用接口,就是面向灵活,项目的可扩展性,可维护性都极高.接口不关心实现类的类型.使用时接口指向实现类,切换实现类即可切换整个功能. (核心)IOC(Inversion of Control)控制反转：是把传统上由程序代码直接操控的对象(自己创建new的对象)的调用权交给容器，通过容器实现对象的创建，属性赋值， 依赖的管理。 (核心)面向切面编程(A
Spring框架使用
qq_52391639的博客
08-02 859
​事务事务是由一个或若干个数据库操作所构成，在进行业务处理时一个业务可能会有多个对数据库的操作，这些操作可能会出现异常在执行过程中产生中断，为了确保用户对数据库数据的操作具有一致性，需要通过事务对这些操作进行管理，被事物进行管理的操作在执行后不会立即提交给数据库，而是等待被同一个事务管理的所有数据库操作执行完后，在确保所有的操作都不出异常的情况下，再进行事务的提交，如果这些操作中存在了异常情况，事务会进行回滚撤销之前已经执行的操作，这样就可以确保数据库在一次业务处理时数据库数据的一致性。...
spring技术详解
热门推荐
爱是一种信仰
07-31 4万+
一：spring的基本用法： 1，关于spring容器： spring容器是Spring的核心，该 容器负责管理spring中的java组件， ApplicationContext ctx  = new ClassPathXmlApplicationContext("bea
spring入门概况和使用方法（一）
u010513603的博客
12-06 262
Spring 的核心是控制反转 （IoC）和面向切面（AOP） EE 开发分成三层结构: * WEB 层:Spring MVC. * 业务层:Bean 管理:(IOC) * 持久层:Spring 的 JDBC 模板.ORM 模板用于整合其他的持久层框架.  Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理 AOP
Spring 温习笔记(一)Spring框架的概述及基本使用方法
xueshanfeitian的博客
01-21 239
Spring 概述 什么是Spring Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架 Spring 发
springboot start.aliyun.com java8
最新发布
JavaUpgrade
07-15 144
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
深入指南：Spring框架与工具
"Apress Pro Spring 5：深入指南——针对Spring框架及其工具的第五版" 本书《ProSpring5：深入指南——Spring框架及其工具》是关于Spring框架的详尽教程，由Iuliana Cosmina、Rob Harrop、Chris Schaefer和Clarence...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值