Spring5框架的使用（基于注解，快速入门）

最新推荐文章于 2023-07-20 01:23:02 发布
最新推荐文章于 2023-07-20 01:23:02 发布
阅读量331 收藏
点赞数
文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44440311/article/details/126807210
版权

        之前系统地学习了Spring5框架的使用，比如IOC的实现、AOP的底层原理与实现方法等，现在用此文章做一个记录，方便之后使用的时候出现遗忘。

一.   概念

        Spring 是轻量级的开源的 JavaEE 框架。
        Spring 有两个核心部分：IOC 和 Aop ：
        （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理
        （2）Aop：面向切面，不修改源代码进行功能增强

         个人理解：IOC控制反转的作用就是，本来我们需要不断地new出新的对象，现在可以直接通过注解的方式，让Spring来自动地创建需要的对象，减少了复杂性。AOP面向切面，就是说，本来有个功能A，如果我们要在其之前、或者之后再添加一些功能，本来需要在功能A中修改源码，现在能够使用注解的方式完成自动修改，无需修改源码。

二.  IOC操作Bean管理（基于注解方式）

        本来要通过xml文件来配置Bean（也就是各个类和对象）管理，现在用注解的方式更加简便快捷。
        Spring针对Bena管理中创建对象提供以下四种注解：
        （1）@Component （2）@Service （3）@Controller （4）@Repository
        功能是一样地，都是用来创建bean实例。

2.1  创建对象的具体步骤

步骤1：引入依赖包（建议使用版本高一些的，不然可能会报错）

步骤2：xml文件中开启组件扫描

            xml要放在src源文件目录下，首先要在<beans>标签中加入配置：

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

        开启组件扫描：

        （因为需要Spring自动扫描寻找“注解”，所以要设定扫描的包是什么，例如我要扫描com.zqh包下的所有文件可能出现的注解，那么就这样操作：

        注意，步骤二也可以替换成完全注解开发，例如下图，来替代xml文件。
        

步骤3：在需要创建对象的类上添加“注解”

        使用上文提到的四种注解任意一个即可，例如下图，UserService类的属性值就是userService。(注意，如果不写value，默认的value为首字母小写的类名，即userService）
        

         以上步骤完成后，测试一下：我们就可以通过以下步骤的getBean方法，得到value为userService类的对象实例，即可完成对象创建了。

2.2  注入属性的具体步骤

        何为注入属性？我的理解是
        注入属性既可以是：
        为某一个属性赋值：例如private String name，我现在让这个name = ‘zqh’，这是一种注入属性。
        还有可以：
        比如说在javaweb的Dao持久层中，通常会先写出Dao接口和DaoImple的接口实现类，那么如果在service中定义private Dao dao，我们可以让他指向其实现类：
        完成：Dao dao = new DaoImpl（）；也是一种属性注入。

        属性注入的注解关键字为：
      @Autowired、@Qualifier、@Value

步骤1：

        在需要实现属性注入的类的上方加入关键字，例如：
        

步骤2：

        直接在需要注入的属性上方添加注解关键字。例如我们在Service方法中添加以下内容。
        其中，Autowired关键字会自动搜索关键字，寻找合适的对象创建实例。
        Qualifier关键字是在用于有多个实现类的情况，无法自动实现，则用这个注解。value就是设置的类的value值
        Value用于直接给属性赋值。

 三.  AOP面向切面编程

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

AOP的几个术语

        1.连接点：可以被增强的类
        2.切入点 ：实际被增强的类
        3.通知：就是增强部分的功能（逻辑），共5中通知类型：

        4.切面：把通知运用到切入点的过程

具体步骤

步骤1：引入AOP相关依赖
        

 步骤2：创建切入点类User（举例）和增强类UserProxy
        
        

 步骤3：在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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--开启扫描-->
    <context:component-scan base-package="aop_Ano"></context:component-scan>

    <!-- 开启 Aspect 生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

        Aspect用于生成代理对象，是AOP所必须的。
        同样的，该步骤也可以采用注解来替代：

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

步骤4：在增强类上添加注解 @Aspect

        主要有五种通知，顾名思义，例如before就是在切入点之前要执行的通知。
        需要介绍一下execution的作用：指明被增强的是哪个类的哪个方法
        格式：execution([权限修饰符]  [返回类型] [类全路径] [方法名称]([参数列表]) )
        本例中，包名aop_Ano，类名User,被增强的方法add()，参数无，写".."

package aop_Ano;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @Author ZhangQihao
 *  execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
 *  作用：指明被增强的哪个类的哪个方法
 */
@Component
@Aspect
@Order(3)
public class UserProxy {
    @Pointcut(value = "execution(* aop_Ano.User.add(..))")
    public void pointdemo() {
    }
    //前置通知
    @Before(value = "pointdemo()")//被增强的哪个类的哪个方法
    public void before() {
        System.out.println("before!!");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "pointdemo()")
    public void afterReturning() {
        System.out.println("后置通知");
    }

    //最终通知
    @After(value = "execution(* aop_Ano.User.add(..))")
    public void after() {
        System.out.println("最终");
    }

    //异常通知
    @AfterThrowing(value = "execution(* aop_Ano.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "execution(* aop_Ano.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
    }
}

        在以上代码中，我们发现，如果对一个同一个切点多次增强，要写很多个execution，非常不方便，所以可以对同一个切点使用PointCut方法来设置目标切点，后面的注解直接使用PointCut下的方法即可。例如：

 步骤5：若有多个增强类对同一个切点增强，使用Order排序

四.  使用Spring框架实现JdbcTemplate与事务

1.JDBCTemplate

        顾名思义，是一种模板，方便快速调用sql语句对数据库进行操作完成crud。使用的时候只需要提供相应的sql语句和其中的变量即可。例如：当我们想增加一条数据
      

步骤1：引入相关jar包

 步骤2：配置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:aop="http://www.springframework.org/schema/aop"
       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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.zqh.spring5"></context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource11" 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="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

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

</beans>

步骤3：创建相应的Dao层和Servie层

         其中，entity用于初始化存入对象的属性。dao中的接口用于定义增删改查的各种方法，而impl用于实现。
        以下是impl实现的具体代码，采用Autowire来创建JDBCTemplate的对象实例，然后调用其中的方法来完成对数据库的crud。
        其中的方法：
        update是用于”修改“数据库中的数据，我们辅佐以sql语句，就可以实现增加和删除和修改这三项功能。batchUpdate就是按组修改，即一次可以进行多条增删改。
        queryForObject用于“查”，那么我们可以辅佐以sql语句实现一些功能，例如查找id为？的一条数据。而query可以查找多条，用于查全部（select * from ......）。

package com.zqh.spring5.dao;

import com.zqh.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.Arrays;
import java.util.List;

/**
 * @Author ZhangQihao
 * （1）@Component
 * （2）@Service
 * （3）@Controller
 * （4）@Repository
 * * 上面四个注解功能是一样的，都可以用来创建 bean 实例
 */
@Repository
public class bookDaoImpl implements bookDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        String sql = "insert into t_book values(?,?,?)";
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);//增加了update条记录
    }

    //增加一条记录
    @Override
    public void update(Book book) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    //批量增加
    @Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        //batchUpdate用于批量添加，底层会遍历List集合，把其中每一个Object数组内的几个数据提取出来，并封装成book对象进行添加。
        System.out.println(Arrays.toString(ints));
    }

    //批量修改
    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
    @Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "delete from t_book where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //删
    @Override
    public void delete(String id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    //查select一条or多条
    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

    @Override
    public Book FindBookInfo(String id) {
        String sql = "select * from t_book where user_id = ?";
//      RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
        //我理解是，把数据封装到Book的对象中去
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

    //封装的区别，关键在于使用的jdbc方法不同，一个是queryfoObject，一个是query（用于多条）
    @Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }
}

        最后编写个测试类测试一下即可：
  

2.事务

        学过数据库应该知道，事务是数据库操作最基本单元，特点是：逻辑上一组的操作，要么都成功，如果有一个失败则所有操作都失败。
        事务的四个特性：（1）原子性 （2）一致性 （3）隔离性 （4）持久性
        事务需要添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

步骤1：配置xml

（1）在 spring 配置文件引入名称空间 tx

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

（2）在上文1中的基础上，开启事务注解和创建事务管理器（本例中数据库连接池的bean的id为dataSource22）

<!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>


    <!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源(对那个数据库进行操作)-->
        <property name="dataSource" ref="dataSource22"></property>
    </bean>

以上模块也可以使用完全注解开发:
@Configuration注解的作用：声明一个类为配置类，用于取代bean.xml配置文件注册bean对象。

package com.zqh.spring5.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

/**
 * @Author ZhangQihao
 */
@Configuration //配置类
@ComponentScan(basePackages = "com.zqh") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }
    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager
    getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new
                DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

步骤3：在需要用到事务的Service类或者具体方法的上方添加@Transactional注解

        例如本例中的bookService：
        可以设置传播类别和隔离级别。

 以上。

好奇的7号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
springMVC入门框架（非注解）
09-02
框架简单易懂适合初学者
Spring5笔记1.介绍和基本使用
Xingqiwudexiawu的博客
07-18 90
3.设置xml文件配置对象创建。1.导入maven依赖。
spring05:Spring注解开发详细步骤
hhhhhh的博客
11-29 280
4.测试类 使用ApplicationContect 的实现类为AnnotationConfigApplicationContext（注解）applicatinContext.xml加载jdbc.properties配置文件获取连接信息。2.创建service层的UserService接口和实现类。--使用注解开发，需要配置组件扫描-->--加载外部的properties文件-->Spring帮解析，完成Bean的创建和注入。1.创建dao层的UserDao接口和实现类。1.使用新注解代替xml配置文件。
学习Spring5必知必会（7）~Spring tx
伟庭的博客
03-03 219
学习Spring5必知必会（7）~Spring tx
spring5源码篇(11)——spring-tx事务源码
最新发布
笔记罢了
07-20 170
spring5源码篇(11)——spring-tx事务源码
启用组件扫描之Java版本1
virhuiai的专栏
08-07 240
I唱片接口代码 package 音响系统; public interface I唱片 { void 播放(); } package 音响系统; import org.springframework.stereotype.Component; /** * * 没有必要显式配置`天之大专辑` Bean， * 因为这个类使用了`@Component`注解， * `@Component`表明该类会作为组件类, * 所以Spring会为你把事情处理妥当。 * * 不过，**组件扫描默认是不
Spring高级之注解驱动开发视频教程
11-05
系统的学习Spring框架中各个部分，掌握Spring中一些高级特性的使用。 l Spring IoC n 设计模式-工厂模式 n 基础应用-入门案例 n 基础应用-常用注解使用场景介绍及入门 n 高级特性-自定义BeanNameGenerator n 高级...
Spring框架精讲
06-29
介绍了如何使用注解完成Spring的相关功能；介绍了如何借助于Spring搭建JUnit测试环境；详细介绍了什么是AOP，以及AOP的基本示例；介绍了如何使用Spring中的JDBC模块进行持久层的开发与事务的相关概念和Spring的事务...
SSM框架教程Spring+SpringMVC+MyBatis全覆盖_Java热门框架视频教程
11-05
1、Spring简介及快速入门 2、Spring配置文件及其相应API 3、Spring注解开发 4、Spring web环境及其Junit的集成 5、Spring JDBCTemplate的基本使用 6、Spring AOP的介绍及其配置使用 7、Spring的声明式事务控制 8、...
千锋JavaEE精讲之Spring框架实战教程
07-22
同时讲解了xml和注解两种方式使用Spring的示例。  通过Spring的入门程序介绍了Spring的IoC和DI的概念，介绍了Spring的基本模块。详细介绍了对象创建的细节和依赖注入的几种方式；介绍了如何使用注解完成Spring...
spring5 jar包
02-16
包含16个最新的spring-5.0.0.M4版本的jar包
Spring - IOC注解开发
Shine bright like a diamond ！
09-29 724
准备工作：创建Maven项目，导入依赖坐标编写代码并注解配置：编写dao层、service层代码，使用注解配置bean：代替xml里的标签使用注解依赖注入：代替xml里的和标签在xml配置文件中开启组件扫描测试 2) 编写代码，并注解配置 接口 实现类 接口 实现类 3) 开启组件扫描 创建，注意引入的名称空间 4) 功能测试 创建一个测试类，调用Service 步骤小结 导入依赖定义接口和实现类（dao 和 service）在实现类上面打上注解 @Component
组件扫描配置 [XML方式]
m0_57001006的博客
02-23 376
use-default-filters : 设置是否进行默认过滤。我们能看到,组件扫描标签是在context名称空间下面的。base-package : 要进行扫描的包。
Spring5详解
qq_45592174的博客
07-13 5410
Spring5详解 文章目录Spring5详解概念Spring的特点1、轻量级2、控制反转3、面向切面4、容器5、框架Spring的优势1、方便解耦，简化开发2、AOP 编程的支持3、声明式事务的支持4、方便程序的测试5、方便集成各种优秀框架6、Java 源码是经典学习范例Spring 的体系结构Spring中的常用注解Spring IOC1、概念2、spring 中工厂的类结构图1、BeanFactory 和 ApplicationContext 的区别2、IOC 中 bean 标签和管理对象细节1、be
【笔记】Spring5基本使用
m0_52739647的博客
10-15 507
Spring 1.Spring概述 历史简介 2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。 很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。 Spring理念 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术 SSH：Struct2+Spring+Hibernate SSM:S
10-Spring5 基于注解方式创建bean实例
鸣鼓ming的博客
10-19 357
1、什么是注解 （1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…) （2）使用注解，注解作用在类上面，方法上面，属性上面 （3）使用注解目的：简化 xml 配置 2、创建对象提供的常用注解 （1）@Component （2）@Service （3）@Controller （4）@Repository 上面四个注解都可以用来创建 bean 实例 3.编码测试 1.需要引入依赖 2.代码编写 UserService package com.limi.service;
Java系列技术之SpringMVC5框架
09-21
Spring MVC是当前最优秀的MVC框架，这门课程是基于Spring5.0.6的SpringMVC框架来讲解的，本套视频几乎涵盖 SpringMVC 开发过程中所有的技术问题，学习本套视频后，你会真正理解 SpringMVC 的优雅和简洁，并使你具备开发 SpringMVC 企业级项目的能力！
spring框架：（五）全注解IOC小案例
weixin_44820069的博客
07-22 259
说明：舍弃xml配置，全注解Ioc；基于 “spring框架：（四）基于xml的 IOC小案例” 的更改；    如有必要请参见：spring框架：（四）基于xml的 IOC小案例            spring框架：（三）IOC注解 1、 新增注解 @Configuration @ComponentScan @Bean 注：此处未提及注解可参见：spring框架：（三）IOC...
Spring5概述 与 Spring5简单案例
shiyansama的博客
06-29 142
Spring5概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 入门案例 下载spring5
spring框架如何入门
04-25
要入门Spring框架，首先需要了解Spring的核心理念和概念，如控制反转（IoC）、依赖注入（DI）、面向切面编程（AOP）等。其次建议学习Spring的基础模块，如Spring IOC、Spring AOP、Spring MVC等模块，可以通过官方...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

好奇的7号

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

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

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

打赏作者

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

抵扣说明：

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

余额充值