Spring学习（二）

最新推荐文章于 2022-11-06 20:56:18 发布
最新推荐文章于 2022-11-06 20:56:18 发布
阅读量223 收藏
点赞数
分类专栏： java学习之路 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52143183/article/details/122821158
版权

文章目录

四、注解开发

在spring4之后，想要使用注解形式，必须得要引入aop的包（spring-webmvc已导入，无需再次导入spring-aop包）

在配置文件当中，需要引入一个context约束：

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

然后在bean中配置：

<!-- 开启注解的支持 -->
<context:annotation-config/>
<!-- 指定扫描的包 -->
<context:component-scan base-package="com.rui"/>

常见的注解有：

  • Bean实现 -> @Component
  • 注入属性 -> @Value
  • 衍生注解 -> @Controller：web层、@Service：service层、@Repository：dao层
  • 自动装配 -> @Autowired、@Qualifier、@Resource
  • JavaConfig -> @Configuration、@ComponentScan、@Import

4.1、Bean实现

1、配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.rui.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "xiaoming";
}

4.2、注入属性

使用注解注入属性

1、可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("xiaoming")
   // 相当于配置文件中 <property name="name" value="秦疆"/>
   public String name;
}

2、如果提供了set方法，也可以在set方法上添加@value(“值”);

@Component("user")
public class User {

   public String name;

   @Value("xiaoming")
   public void setName(String name) {
       this.name = name;
  }
}

4.3、衍生注解

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

  • @Controller：web层
  • @Service：service层
  • @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

其他注解

  • @scope作用域
@Controller("user")
@Scope("prototype")
public class User {
   @Value("xiaoming")
   public String name;
}
  • @Autowired、@Qualifier、@Resource自动装配注解，见下

4.4、自动装配

  • @Autowired按类型自动转配的
  • @Qualifier根据byName的方式自动装配
  • @Resource兼顾两者自动装配方式

1、在spring配置文件中引入context文件头

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解支持！

<context:annotation-config/>

@Autowired

注：需要导入 spring-aop的包！

测试：

1、将User类中的set方法去掉，使用@Autowired注解

public class User {
   @Autowired
   private Cat cat;
   @Autowired
   private Dog dog;
   private String str;

   public Cat getCat() {
       return cat;
  }
   public Dog getDog() {
       return dog;
  }
   public String getStr() {
       return str;
  }
}

2、此时配置文件内容

<!-- 开启属性注解支持！ -->
<context:annotation-config/>

<bean id="dog" class="com.rui.pojo.Dog"/>
<bean id="cat" class="com.rui.pojo.Cat"/>
<bean id="user" class="com.rui.pojo.User"/>

拓展：@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)

@Qualifier

  • @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配

  • @Qualifier不能单独使用。

测试实验步骤：

1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.kuang.rui.Dog"/>
<bean id="dog2" class="com.kuang.rui.Dog"/>
<bean id="cat1" class="com.kuang.rui.Cat"/>
<bean id="cat2" class="com.kuang.rui.Cat"/>

2、没有加Qualifier测试，直接报错

3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

测试，成功输出！

@Resource

  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
  • 其次再进行默认的byName方式进行装配；
  • 如果以上都不成功，则按byType的方式自动装配。
  • 都不成功，则报异常。

实体类：

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

beans.xml

<bean id="dog" class="com.rui.pojo.Dog"/>
<bean id="cat1" class="com.rui.pojo.Cat"/>
<bean id="cat2" class="com.rui.pojo.Cat"/>

<bean id="user" class="com.rui.pojo.User"/>

测试：结果OK

配置文件2：beans.xml ， 删掉cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结论：先进行byName查找，失败；再进行byType查找，成功。

自动装配注解开发小结：

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

4.5、JavaConfig

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。

测试：

1、编写一个实体类，Dog

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
   public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //这是一个配置类，类似beans.xml
@ComponentScan("com.rui.pojo")
public class MyConfig {

   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }

}

3、测试

@Test
public void test2(){
   ApplicationContext applicationContext =
           new AnnotationConfigApplicationContext(MyConfig.class);
   Dog dog = (Dog) applicationContext.getBean("dog");
   System.out.println(dog.name);
}

4、成功输出结果！

导入其他配置如何做呢？

1、我们再编写一个配置类！

@Configuration  //这是一个配置类，类似beans.xml
public class MyConfig2 {
}

2、在之前的配置类中我们来选择导入这个配置类

@Configuration
@Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {

   @Bean
   public Dog dog(){
       return new Dog();
  }

}

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

五、AOP

5.1、简介

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

**作用：**提供声明式事务；允许用户自定义切面

5.1.1、AOP的主要角色
  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点。图片
5.1.2、Advice的主要类型

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

通知类型连接点实现接口注解
前置通知方法方法前org.springframework.aop.MethodBeforeAdvice@Before
后置通知方法后org.springframework.aop.AfterReturningAdvice@AfterRunning
环绕通知方法前后org.aopalliance.intercept.MethodInterceptor@Around
异常抛出通知方法抛出异常org.springframework.aop.ThrowsAdvice@AfterThrowing
引介通知类中增加新的方法属性org.springframework.aop.IntroductionAdvisor

注：@Before是业务逻辑执行前执行，与其对应的是@AfterReturning，而不是@After，@After是所有的切面逻辑执行完之后才会执行，无论是否抛出异常。

5.1.3、切点表达式

在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点"

例如定义切入点表达式 execution (* com.sample.service.impl…*.*(…))

execution()是最常用的切点函数，其语法如下所示：

整个表达式可以分为五个部分：

1、execution(): 表达式主体。

2、第一个*号：表示返回类型， *号表示所有的类型。

3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

4、第二个* 号：表示类名，*号表示所有的类。

5、(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

更多的Aop表达式可参考Spring AOP切点表达式用法总结 - 博客园

5.2、Spring实现Aop的三种方式

【重点】使用AOP织入，需要在pom.xml导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>
5.2.1、通过 Spring API 实现

首先编写我们的业务接口和实现类

public interface UserService {

   public void add();

   public void delete();

   public void update();

   public void search();

}
public class UserServiceImpl implements UserService{

   @Override
   public void add() {
       System.out.println("增加用户");
  }

   @Override
   public void delete() {
       System.out.println("删除用户");
  }

   @Override
   public void update() {
       System.out.println("更新用户");
  }

   @Override
   public void search() {
       System.out.println("查询用户");
  }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

public class BeforeLog implements MethodBeforeAdvice {

   //method : 要执行的目标对象的方法
   //objects : 被调用的方法的参数
   //Object : 目标对象
   @Override
   public void before(Method method, Object[] objects, Object o) throws Throwable {
       System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
  }
}
public class AfterLog implements AfterReturningAdvice {
   //returnValue 返回值
   //method被调用的方法
   //args 被调用的方法的对象的参数
   //target 被调用的目标对象
   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
       System.out.println("执行了" + target.getClass().getName()
       +"的"+method.getName()+"方法,"
       +"返回值："+returnValue);
  }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!--注册bean-->
   <bean id="userService" class="com.rui.service.UserServiceImpl"/>
   <bean id="beforelog" class="com.rui.log.BeforeLog"/>
   <bean id="afterLog" class="com.rui.log.AfterLog"/>

   <!--aop的配置-->
   <aop:config>
       <!--切入点 expression:表达式匹配要执行的方法-->
       <aop:pointcut id="pointcut" expression="execution(* com.rui.service.UserServiceImpl.*(..))"/>
       <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
       <aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   </aop:config>

</beans>

测试

public class MyTest {
   @Test
   public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.search();
  }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

5.2.2、自定义类来实现

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

public class DiyPointcut {

   public void before(){
       System.out.println("---------方法执行前---------");
  }
   public void after(){
       System.out.println("---------方法执行后---------");
  }
   
}

去spring中配置

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.rui.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
   <!--第二种方式：使用AOP的标签实现-->
   <aop:aspect ref="diy">
       <aop:pointcut id="diyPonitcut" expression="execution(* com.rui.service.UserServiceImpl.*(..))"/>
       <aop:before pointcut-ref="diyPonitcut" method="before"/>
       <aop:after pointcut-ref="diyPonitcut" method="after"/>
   </aop:aspect>
</aop:config>

测试：

public class MyTest {
   @Test
   public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.add();
  }
}
5.2.3、使用注解实现

第一步：编写一个注解实现的增强类

package com.rui.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
   @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void before(){
       System.out.println("---------方法执行前---------");
  }

   @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void after(){
       System.out.println("---------方法执行后---------");
  }

   @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void around(ProceedingJoinPoint jp) throws Throwable {
       System.out.println("环绕前");
       System.out.println("签名:"+jp.getSignature());
       //执行目标方法proceed
       Object proceed = jp.proceed();
       System.out.println("环绕后");
       System.out.println(proceed);
  }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.rui.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class=“true”/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

Spring学习笔记均参考于“狂神说”

叶辰 .
关注
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 9万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
Spring 实例源码
12-26
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。 在这篇由三部分组成的 Spring 系列 的第 1 部分中，我将介绍 Spring 框架。我先从框架底层模型的角度描述该框架的功能，然后将讨论两个最有趣的模块：Spring 面向方面编程（AOP）和控制反转 （IOC） 容器。接着将使用几个示例演示 IOC 容器在典型应用程序用例场景中的应用情况。这些示例还将成为本系列后面部分进行的展开式讨论的基础，在本文的后面部分，将介绍 Spring 框架通过 Spring AOP 实现 AOP 构造的方式。
初识Spring框架(附案例源码)＜2＞
qq_45992570的博客
12-29 231
快速上手Spring 1.编写一个Hello实体类 public class Hello { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public void show(){ System.out.println("
Spring小例子项目源码
09-27
项目源码，内有Spring AOP、事务、线程小例子，还有AOP实现原理，动态代理，java多线程
spring源码案例
weixin_47068446的博客
07-11 385
​ 一般情况下，Spring通过反射机制利用bean的class属性指定实现类来实例化bean。在某些情况下，实例化bean过程比较复杂，如果按照传统的方式，则需要在标签中提供大量的配置信息，配置方式的灵活性是受限的。为此，Spring可以通过实现FactoryBean的接口来定制实例化bean的逻辑。​ 1、创建Car对象 ​ 2、创建CarFactoryBean ​ 3、修改配置文件 ​ 4、测试代码 2、扩展initPropertySources方法 ​ 1、继承具体的类并扩展实现 ​
Spring 学习源码示例
weixin_60808029的博客
05-18 577
Spring IoC 控制反转的案例。Spring 依赖注入方式（两种）的源码示例（setter 注入、有参构造函数注入）。Spring 基于XML的AOP开发的源码示例。Spring 基于XML实现事务管理的源码示例
springcloud学习笔记.pdf
03-12
Spring Cloud 学习笔记 本笔记主要介绍了从单体架构到微服务架构的演变过程，以及 Spring Cloud 中的微服务架构搭建。下面是本笔记的详细知识点总结： 一、单体架构 单体架构是指整个系统只有一个工程，打包往往...
《springcloud&学习资料》--尚硅谷SpringCloud视频学习笔记.zip
最新发布
04-19
无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ 个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论...
springcloud视频学习
01-20
二、SpringCloud Rest微服务案例-总体概述 15.尚硅谷_SpringCloud_Rest微服务案例-总体概述.avi视频教程则聚焦于基于RESTful API的微服务实战，主要讲解以下知识点： 1. RESTful API设计原则：包括资源定位、HTTP...
spring学习
06-05
在"spring学习"的资源包中，我们看到三个关于"第四章 Spring的基本用法"的PPT文件，分别是"第一次"、"第三次"和"第二次"。虽然顺序可能有些混乱，但我们可以从中提取出一系列关键知识点。 1. **依赖注入**：Spring...
Spring+SpringMVC+MyBatis整合工程实例 完整版源码（带注释）
07-19
这个SSM框架整合工程是基于IntelliJ IDEA完成的的，工程里面配置文件均有注释，可直接拷贝使用（工程代码可导入IDEA中直接运行）
Spring进行AOP操作需要的4个jar包
05-19
Spring进行aop操作需要的4个jar包，包括aopalliance-1.0.jar、aspectjweaver-1.8.9.jar、spring-aop-4.3.0.RELEASE.jar、spring-aspects-4.3.0.RELEASE.jar。
初识Spring框架
weixin_46972127的博客
07-04 419
目录1、为什么要学框架2、Servlet vs SpringBoot2.1 servlet框架步骤2.2 SpringBoot框架的步骤2.3 二者比较3、Spring核心与设计思想3.1 初识Spring3.2 什么是IoC？3.3什么是DI4、Spring创建与使用4.1 创建 Spring项目4.2 存储 Bean 对象4.3 获取并使用Bean对象4.3 总结学习框架相当于从”小作坊“到”工厂“的升级，小作坊什么都需要自己来完成，而框架就在一定意义上实现了自动化，框架更加易用、简单且高效。①首先创建
Spring框架概述以及入门案例
while(true){ study }
07-31 269
1、Spring是轻量级的开源的JavaEE框架2、Spring可以解决企业应用开发的复杂性3、Spring有两个核心部分IOC和AOP之前创建对象时候，都是要new一个类，然后把对象创建，而IOC就是把创建对象的过程，交给Spring进行管理，也就是Spring帮我们去创建对象，我们就不用new的方式去做了。比如说我想在程序中加个功能，或者扩展功能一个功能，按照原始方式，我们需要改变源代码进行实现，而AOP可以在不修改源代码的情况下，进行功能的添加或增强。4、Spring特点。......
【Java开发】 Spring 01：初识 Spring
尹煜的博客
11-06 440
虽然接触项目开发有一段时间了，可是在 Spring 框架前依然是一个小白，因此有必要系统性地对Spring进行学习， 本栏目基于极客时间平台的《玩转 Spring 全家桶》课程完成的笔记~
Spring 从实例读源码系列
songxinjianqwe的博客
12-18 1153
Spring 从实例读源码系列更为完整的笔记传送门 Github简介差不多花了一周的时间大概地阅读了Spring的IOC、AOP、Transaction和MVC四个模块的源码，先分别总结如下。 大概使用了以下方法阅读源码 1. 读书《Spring源码深度解析》 2. 读了一些dalao的Spring源码的博客文章 3. 下载源码在IDE里面静态阅读 4. 对源码进行debug，单步
Spring源码浅析
wdx1121的博客
07-12 251
启动Spring容器，加载xml配置文件调用构造器调用本类构造器，设置配置文件路径，然后执行refresh方法。refresh方法。进来先执行prepareRefresh准备方法，其中设置启动时间，其他设置等等，执行完会打印：refresh中继续执行：这里面会加载指定的xml配置文件，创建对象工厂。refresh中继续执行：prepareBeanFactory中对象工厂的一些设置。继续执行：支持国...
spring项目源码下载地址
三月泡生长在阳春三月天，把鲜红的美味奉献给世人
12-23 770
总地址：https://github.com/spring-projects =》根据自己的需要选择下载； springboot地址：https://github.com/spring-projects/spring-boot spring framework地址：https://github.com/spring-projects/spring-framework...
Spring框架新手入门学习笔记（内附源码）
zwei1999的博客
04-09 242
Spring 1.本章主要内容 1.1.Spring框架概要 1.2.IOC容器 (***） 1.3.AOP （***） 1.4.jdbcTemplate 1.5.事务管理 （***） 1.6.Spring5新特性 1.7.Spring整合Mybatis （*） 2.Spring概要 概述：它是轻量级的开源的JavaEE框架 轻量级：它的体积小，依赖的jar包比较少，并且不需要额外依赖其他的组件 开源：免费提供源代码 框架：可以简化我们构建软件的过程 目的：为了解决企业级应
Spring 2.5 整合与AOP实践学习笔记
"Spring2.5 学习笔记" 在学习Spring 2.5的过程中，我们需要理解这个版本的核心特性，特别是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）。以下是对每个章节的详细解释...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

叶辰 .

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

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

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

打赏作者

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

抵扣说明：

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

余额充值